用边值分析和等价类划分技术来推导和编写数独验证器实现的测试。
用边值分析和等价类划分技术来推导和编写数独验证器实现的测试。需要报告如何确定所选变量的有效边界和无效边界
这个suduku的是你自己定义的？怎么输入的
有效输入自然就是盘面数字在1-9之内，边界就是上下界
无效就是超过边界，比如说输入了-1
或者明显已经构成的行列块已经出现了重复
参考GPT和自己的思路：数独验证器是一个程序，用于验证给定的数独游戏是否是有效的。在进行测试之前，需要确定有效和无效输入的边界。以下是使用边界值分析和等价类划分技术来推导和编写数独验证器实现的测试：
1 等价类划分
等价类划分将所有可能的测试数据分为不同的类别，每个类别都具有相同的测试结果。以下是数独验证器的等价类：
等价类1：有效数独。这是一个符合数独游戏规则的数独。
等价类2：无效数独。这是一个不符合数独游戏规则的数独，其中包含重复数字或不完整的行、列或九宫格。
2 边界值分析
边界值分析确定了每个等价类的有效和无效边界。以下是数独验证器的边界值：
等价类1：有效数独。
有效边界：c是一个完整、无重复数字的数独字符串。
无效边界：c为空字符串、包含非数字字符、包含重复数字或长度不足 81 个字符。
等价类2：无效数独。
有效边界：i是一个数独字符串，其中包含重复数字或不完整的行、列或九宫格。
无效边界：i为空字符串、包含非数字字符、包含符合规则的数独字符串或长度不足 81 个字符。
基于以上的等价类和边界值，我们可以编写以下的测试用例：
import static org.junit.Assert.*;
import org.junit.Test;
public class SudokuVerifierTest {
String validSudoku = "417369825632158947958724316825437169791586432346912758289643571573291684164875293";
String invalidSudoku = "12345678991234567889123456778912345667891234556789123445678912334567891223457891";
SudokuVerifier verifier = new SudokuVerifier();
@Test
public void testValidSudoku() {
int result = verifier.verify(validSudoku);
assertEquals("valid sudoku", 0, result);
}
@Test
public void testInvalidSudoku() {
int result = verifier.verify(invalidSudoku);
assertEquals("invalid sudoku", -2, result);
}
@Test
public void testEmptyString() {
int result = verifier.verify("");
assertEquals("empty string", -1, result);
}
@Test
public void testNonNumericString() {
int result = verifier.verify("abcd1234");
assertEquals("non-numeric string", -1, result);
}
@Test
public void testShortString() {
int result = verifier.verify("123456789");
assertEquals("short string", -1, result);
}
@Test
public void testLongString() {
int result = verifier.verify(validSudoku + "0"); // 添加一个额外的数字
assertEquals("long string", -1, result);
result = verifier.verify(validSudoku.substring(0, 80)); // 删除最后一个数字
assertEquals("short string", -1, result);
result = verifier.verify(validSudoku.substring(1) + validSudoku.charAt(0)); // 将第一个数字移到最后一个位置
assertEquals("invalid sudoku", -2, result);
result = verifier.verify(validSudoku.substring(0, 8) + validSudoku.charAt(0) + validSudoku.substring(9)); // 在第一行中添加重复的数字
assertEquals("invalid sudoku", -2, result);
result = verifier.verify(validSudoku.substring(0, 16) + validSudoku.charAt(0) + validSudoku.substring(17)); // 在第一列中添加重复的数字
assertEquals("invalid sudoku", -2, result);
result = verifier.verify(validSudoku.substring(0, 26) + validSudoku.charAt(0) + validSudoku.substring(27)); // 在第一宫中添加重复的数字
assertEquals("invalid sudoku", -2, result);
result = verifier.verify(validSudoku.substring(3)); // 将第一行删除
assertEquals("invalid sudoku", -2, result);
result = verifier.verify(validSudoku.substring(0, 27) + validSudoku.substring(30)); // 将第一列删除
assertEquals("invalid sudoku", -2, result);
result = verifier.verify(validSudoku.substring(0, 21) + validSudoku.substring(24)); // 将第一宫删除
assertEquals("invalid sudoku", -2, result);
}
参考GPT和自己的思路，以下是使用边界值分析和等价类划分技术编写的测试代码：
public class SudokuVerifierTest {
String correctSudoku = "417369825632158947958724316825437169791586432346912758289643571573291684164875293";
String incorrectSudoku = "123456789912345678891234567789123456678912345567891234456789123345678912234567891";
SudokuVerifier verifier = new SudokuVerifier();
// Test for valid Sudoku strings
@Test
public void testValidSudoku() {
int result = verifier.verify(correctSudoku);
assertEquals("Valid Sudoku string", 0, result);
}
// Test for invalid Sudoku strings
@Test
public void testInvalidSudoku() {
int result = verifier.verify(incorrectSudoku);
assertEquals("Invalid Sudoku string", -2, result);
}
// Test for empty Sudoku strings
@Test
public void testEmptySudoku() {
int result = verifier.verify("");
assertEquals("Empty Sudoku string", -1, result);
}
// Test for Sudoku strings with less than 81 characters
@Test
public void testShortSudoku() {
int result = verifier.verify(correctSudoku.substring(0, 80));
assertEquals("Short Sudoku string", -1, result);
}
// Test for Sudoku strings with more than 81 characters
@Test
public void testLongSudoku() {
int result = verifier.verify(correctSudoku + "1");
assertEquals("Long Sudoku string", -1, result);
}
// Test for Sudoku strings with invalid characters
@Test
public void testInvalidCharacters() {
String sudoku = "41A369825632158947958724316825437169791586432346912758289643571573291684164875293";
int result = verifier.verify(sudoku);
assertEquals("Sudoku string with invalid characters", -3, result);
}
// Test for Sudoku strings with duplicate numbers in rows
@Test
public void testDuplicateNumbersInRows() {
String sudoku = "417369825632158947958724316825437169791586432346912758289643571573291684164875292";
int result = verifier.verify(sudoku);
assertEquals("Sudoku string with duplicate numbers in rows", -4, result);
}
// Test for Sudoku strings with duplicate numbers in columns
@Test
public void testDuplicateNumbersInColumns() {
String sudoku = "417369825632158947958724316825437169791586432346912758289643571573291684164875291";
int result = verifier.verify(sudoku);
assertEquals("Sudoku string with duplicate numbers in columns", -5, result);
}
// Test for Sudoku strings with duplicate numbers in regions
@Test
public void testDuplicateNumbersInRegions() {
String sudoku = "417369825632158947958724316825437169791586432346912758289643571573291684164875293";
int i = 20;
char[] chars = sudoku.toCharArray();
chars[i] = chars[i+27];
chars[i+1] = chars[i+28];
chars[i+2] = chars[i+29];
String modifiedSudoku = new String(chars);
int result = verifier.verify(modifiedSudoku);
assertEquals("Sudoku string with duplicate numbers in regions", -6, result);
}
}
根据等价类划分，我们可以将所有可能的输入分成以下三个等价类：
1.有效的数独字符串
2.无效的数独字符串，即长度不为81的字符串
3.无效的数独字符串，即包含不符合数独规则的数字
对于第一个等价类，我们需要找到它的有效边界和无效边界。数独游戏中只有数字1到9是有效的输入，因此我们可以确定每个数字的有效边界为1到9。无效边界为小于1或大于9的数字。另外，数独字符串必须是恰好81个字符，因此其有效边界为长度为81的字符串，无效边界为其他长度的字符串。
对于第二个等价类，无效边界为任何长度小于81的字符串。因为数独必须由81个数字组成。
对于第三个等价类，我们需要确定包含不符合数独规则的数字的无效边界。数独规则要求在每个行、列和3x3子网格中数字不能重复。因此，包含任何重复数字的字符串都是无效的输入。另外，数独字符串中的数字必须在1到9之间，因此包含大于9或小于1的数字也是无效的输入。
该回答引用GPTᴼᴾᴱᴺᴬᴵ
为了使用边界值分析和等价类划分来设计测试用例，我们需要首先确定输入值的有效边界和无效边界。
对于数独验证器，有效输入是一个81个字符的字符串，表示一个已完成的数独谜题。其中，每个字符都必须是数字1-9之间的一个。
无效输入的例子包括：
- 81个字符的字符串，但包含除1-9之外的数字或字母。
- 一个少于81个字符的字符串。
- 一个空字符串或null值。
以下是我们可以使用的边界值和等价类：
有效输入边界：
- 正确的81个数字字符。
- 第一个字符或最后一个字符是1或9。
- 数独谜题的第一行或最后一行缺少数字。
无效输入边界：
- 字符串包含非数字字符或数字字符小于1或大于9。
- 字符串长度小于81个字符。
- 字符串为null或空。
基于上述输入值，我们可以使用边界值分析和等价类划分来设计测试用例。以下是测试用例示例代码：
import static org.junit.Assert.*;
import org.junit.Test;
public class SudokuVerifierTest {
// Test cases for valid input
@Test
public void testValidInput() {
String input = "417369825632158947958724316825437169791586432346912758289643571573291684164875293";
SudokuVerifier verifier = new SudokuVerifier();
int result = verifier.verify(input);
assertEquals(0, result);
}
@Test
public void testValidInput_FirstChar1() {
String input = "117369825632158947958724316825437169791586432346912758289643571573291684164875293";
SudokuVerifier verifier = new SudokuVerifier();
int result = verifier.verify(input);
assertEquals(-1, result);
}
@Test
public void testValidInput_LastChar1() {
String input = "417369825632158947958724316825437169791586432346912758289643571573291684164875291";
SudokuVerifier verifier = new SudokuVerifier();
int result = verifier.verify(input);
assertEquals(-1, result);
}
@Test
public void testValidInput_FirstRowMissing() {
String input = "000000000632158947958724316825437169791586432346912758289643571573291684164875293";
SudokuVerifier verifier = new SudokuVerifier();
int result = verifier.verify(input);
assertEquals(-1, result);
}
@Test
public void testValidInput_LastRowMissing() {
String input = "417369825632158947958724316825437169791586432346912758289643571573291684164875000";
SudokuVerifier verifier = new SudokuVerifier();
int result = verifier.verify(input);
assertEquals(-1, result);
}
// Test cases for invalid input
@Test
public void testInvalidInput_NonNumericChars() {
String input = "4s7369825632158947958724316825437169791586432346912758289643571573291684164875293";
SudokuVerifier verifier = new SudokuVerifier();
- 这个问题的回答你可以参考下: https://ask.csdn.net/questions/7798177
以下答案由GPT-3.5大模型与博主波罗歌共同编写：
数独验证器是一个用于检查数独解是否有效的程序。数独解的有效性取决于其是否符合数独的规则，即每一行、每一列和每一个小九宫格都必须包含数字1到9且不能重复。为了测试数独验证器的正确性，可以使用边值分析和等价类划分技术。
边值分析是一种黑盒测试技术，旨在识别测试数据集中最重要、最频繁出现的“边缘情况”，即软件系统在其输入域的边界值处可能发生的异常行为。在数独验证器的测试中，我们可以考虑以下变量的有效边界和无效边界：
数字填充的位置：有效边界是9x9数独矩阵中的任何一个位置；无效边界是在矩阵外或已填充数字的位置。
填充的数字：有效边界是数字1-9，无效边界是非1-9数字或无。
数独解的有效性：有效边界是一个有效的解；无效边界是无效的解或者不是解。
等价类划分是一种白盒测试技术，旨在将输入条件分为若干等价类，以便设计具有代表性的测试用例。在数独验证器的测试中，我们可以考虑以下等价类：
数字填充的位置：
- 等价类1：空白位置（未填数字）。
- 等价类2：已填数字的位置。
填充的数字：
- 等价类1：填数字1.
- 等价类2：填数字2.
...（直到等价类9）。
- 等价类10：填非1-9数字或无。
数独解的有效性：
- 等价类1：一个有效的数独解；
- 等价类2：一组无效的数独解；
- 等价类3：非数独解。
下面是使用Python语言实现为数独验证器编写的测试代码示例，其中包含了上述的边界和等价类测试设计：
class TestSudokuValidator(unittest.TestCase):
def setUp(self):
self.sudoku = SudokuValidator()
## Edge Testing
# Test the valid boundaries for sudoku coordinates
def testValidateCoordEdgeCase(self):
self.assertEqual(self.sudoku.validateCoord(0,0), True)
self.assertEqual(self.sudoku.validateCoord(8,8), True)
# Test the invalid boundaries for sudoku coordinates
def testInvalidateCoordEdgeCase(self):
self.assertEqual(self.sudoku.validateCoord(-1,-1), False)
self.assertEqual(self.sudoku.validateCoord(0,9), False)
self.assertEqual(self.sudoku.validateCoord(9,0), False)
self.assertEqual(self.sudoku.validateCoord(9,9), False)
self.assertEqual(self.sudoku.validateCoord(5,5,5), False)
# Test the valid boundaries for sudoku values
def testValidateValueEdgeCase(self):
self.assertEqual(self.sudoku.validateValue(1), True)
self.assertEqual(self.sudoku.validateValue(9), True)
# Test the invalid boundaries for sudoku values
def testInvalidateValueEdgeCase(self):
self.assertEqual(self.sudoku.validateValue(0), False)
self.assertEqual(self.sudoku.validateValue(10), False)
self.assertEqual(self.sudoku.validateValue(-1), False)
# Test the valid boundaries for sudoku solutions
def testValidateSolutionEdgeCase(self):
self.assertEqual(self.sudoku.validateSolution(validSudoku), True)
# Test the invalid boundaries for sudoku solutions
def testInvalidateSolutionEdgeCase(self):
self.assertEqual(self.sudoku.validateSolution(invalidSudoku), False)
## Equivalent Class Testing
# Test blank sudoku cells
def testValidateBlankCells(self):
self.assertEqual(self.sudoku.validateCoord(3,3), True)
# Test filled in sudoku cells
def testValidateFilledCells(self):
self.assertEqual(self.sudoku.validateCoord(5,5,5), False)
# Test valid sudoku values (1-9)
def testValidateValidValues(self):
self.assertEqual(self.sudoku.validateValue(6), True)
# Test invalid sudoku values
def testValidateInvalidValues(self):
self.assertEqual(self.sudoku.validateValue(10), False)
# Test a valid sudoku solution
def testValidateValidSolution(self):
self.assertEqual(self.sudoku.validateSolution(validSudoku), True)
# Test an invalid sudoku solution
def testValidateInvalidSolution(self):
self.assertEqual(self.sudoku.validateSolution(invalidSudoku), False)
其中，SudokuValidator()是一个包含了实现数独验证器的类，通过实现相关的边界和等价类的测试用例，我们就可以对数独验证器进行全面的测试以验证其正确性。
如果我的回答解决了您的问题，请采纳！
边值分析是一种测试技术，它基于变量的边界值来设计测试用例。在数独验证器中，变量可以是数独谜题的解，边界值可以是1到9之间的数字。因此，可以使用边值分析来确定以下测试用例：
1. 输入一个有效的数独谜题解，其中所有数字都在1到9之间。
2. 输入一个无效的数独谜题解，其中至少有一个数字不在1到9之间。
3. 输入一个无效的数独谜题解，其中至少有一行、一列或一个3x3的子网格中有重复的数字。
等价类划分是一种测试技术，它将输入值划分为等价类，并为每个等价类设计测试用例。在数独验证器中，可以将输入值划分为以下等价类：
1. 有效的数独谜题解：所有数字都在1到9之间，且没有重复的数字。
2. 无效的数独谜题解：至少有一个数字不在1到9之间。
3. 无效的数独谜题解：至少有一行、一列或一个3x3的子网格中有重复的数字。
因此，可以使用等价类划分来确定以下测试用例：
1. 输入一个有效的数独谜题解。
2. 输入一个无效的数独谜题解，其中至少有一个数字不在1到9之间。
3. 输入一个无效的数独谜题解，其中至少有一行、一列或一个3x3的子网格中有重复的数字。
在确定变量的有效边界和无效边界时，需要考虑变量的取值范围和可能的错误情况。在数独验证器中，变量的取值范围是1到9之间的数字，因此有效边界是1和9，无效边界是小于1和大于9的数字。可能的错误情况包括数字重复和数字不在1到9之间。
综上所述，可以使用边值分析和等价类划分技术来推导和编写数独验证器实现的测试。在确定变量的有效边界和无效边界时，需要考虑变量的取值范围和可能的错误情况。通过设计有效的测试用例，可以确保数独验证器能够正确地验证数独谜题的解。