0

我有以下场景要测试。我想知道哪种测试框架最适合我的要求。

场景一）Param1、Param2、Param3、Param4、Param5

我将使用参数编号1、2、3.. 传递上述参数，直到 20。

对于每个数字（1 到 20），将生成一个文件，该文件是测试输出数据。我需要将此输出数据与预期数据（也是一个文件）进行比较，如果两个文件（测试输出文件和预期数据文件）相同，则生成结果为真，否则为假。

测试的输入如下：Param1、Param2、Param3、Param4、Param5、Number、Expected Data File（将与测试输出进行比较）

场景2）param1，param2，param3，param4，param5

这里将给上述变量分配不同的值，然后将这些值再次传递给测试 20 次，每次都会生成不同的测试输出文件（总共 20 个输出文件），然后与预期的数据文件进行比较。（也有 20 个用于预期数据的文件。）

我有这样的15个场景。哪个测试框架最适合这里？参数化的 Junit 是否合适？请提供一些指导方针，以便使用推荐的框架。

4

3 回答 3

0

1.哪个测试框架最适合这里？
答：类参数化

2.参数化Junit合适吗？
答：是的，你是对的

3.请提供一些指导方针，以便使用推荐的框架。
Ans: 用于断言实际和预期的结果。
假设您想通过 char 检查文件 char 的内容，您可以使用FileUtils.contentEquals(file1, file2) commons apache io

让我们看看这个例子：

public class Calc{

    public static int add(int a, int b) {
        return a + b;
    }

}

朱尼特

@RunWith(value = Parameterized.class)
public class ParameterizedTest {

    private int numberA;
    private int numberB;
    private int expected;

    // Inject via constructor
    // for {8, 2, 10}, numberA = 8, numberB = 2, expected = 10
    public ParameterizedTest(int numberA, int numberB, int expected) {
        this.numberA = numberA;
        this.numberB = numberB;
        this.expected = expected;
    }

    // name attribute is optional, provide an unique name for test
    // multiple parameters, uses Collection<Object[]>
    @Parameters(name = "{index}: testAdd({0}+{1}) = {2}")
    public static Collection<Object[]> data() {
        return Arrays.asList(new Object[][]{
                {1, 1, 2},
                {2, 2, 4},
                {8, 2, 10},
                {4, 5, 9},
                {5, 5, 10}
        });
    }

    @Test
    public void test_addTwoNumbes() {
        assertThat(Calc.add(numberA, numberB), is(expected));
    }

}

参考

于 2018-01-20T09:56:25.203 回答
0

通过将 Junit 参数化测试与一些 YAML 解析相结合，我能够创建可读的参数表。每个表行都将被解析为一个 Map，每个值都将使用 yaml 解析器进行解析。这样，每个地图都包含类型化的实例。甚至在这种情况下列出。

@RunWith(Parameterized.class)
public class AnotherParameterizedTest {

    private final HashMap row;

    @Parameterized.Parameters(name="Reverse Lists Tests # {index}:")
    public static List<Map<String, Object>> data() {
        final TestData testData = new TestData(""+
             "|   ID   |       List         |  Expected   |                \n"+
             "|   0    |    [1, 2, 3]       |  [3, 2, 1]  |                \n"+
             "|   1    |    [2, 3, 5]       |  [5, 3, 2]  |                \n"+
             "|   2    |    [5, 6, 7]       |  [ 7, 6, 5] |                \n"
        );
        // parsing each row using simple YAML parser and create map per row
        return testData.getDataTable();
    }

    public AnotherParameterizedTest(HashMap obj) {
        this.row = obj;
    }

    @Test
    public void test() throws Exception {
        List orgListReversed = new ArrayList((List) row.get("List"));
        Collections.reverse(orgListReversed);
        assertEquals((List) row.get("Expected"), orgListReversed);
    }

}

Junit 测试结果

于 2018-07-10T14:00:28.893 回答
0

作为 Spock 测试的示例，其中所有参数和数字都可以不同：

@Unroll
def "scenario with different parameters"() {
    given:
    def service = new MyService()

    when:
    def actualDataFile = service.doSomething(param1, param2, param3, param4, param5, number)

    then:
    readFileAsString(actualDataFile) == readFileAsString(expectedDataFileName)

    where:
    param1 | param2 | param3 | param4 | param5 | number | expectedDataFileName
    'any'  | 'aaa'  | 'any'  | 'any'  | 'any'  | 1      | 'expectedA.txt'
    'any'  | 'aay'  | '0ny'  | 'any'  | 'any'  | 2      | 'expectedB.txt'
    'any'  | 'ady'  | '3ny'  | 'a__'  | 'a3y'  | 3      | 'expectedC.txt'
    'any'  | 'ady'  | '3ny'  | 'a__'  | 'a3y'  | 4      | 'expectedD.txt'
    'any'  | 'ady'  | '3ny'  | 'a__'  | 'a3y'  | 5      | 'expectedE.txt'
    'any'  | 'ady'  | '3ny'  | 'a__'  | 'a3y'  | 6      | 'expectedF.txt'
    'any'  | 'ady'  | '3ny'  | 'a__'  | 'a3y'  | 7      | 'expectedG.txt'
    'any'  | 'ady'  | '3ny'  | 'a__'  | 'a3y'  | 8      | 'expectedH.txt'
    // etc
}
于 2018-01-20T07:07:23.117 回答