文章/答案/技术大牛

发布

社区首页 >问答首页 >Junit 5测试类结构

问Junit 5测试类结构
EN

Stack Overflow用户

提问于 2017-11-29 11:03:40

回答 1查看 576关注 0票数 0

嗨，我是JUnit的初学者，也是测试的新手。可能是过度考虑了，但我想知道测试代码结构的良好实践。我尝试过很少的方法。如有任何建议，我将不胜感激。

第一种方法:将参数、输入、输出放在类的首位。然后很容易检查或更改整个类的测试条件：

@TestInstance(Lifecycle.PER_CLASS)
public class App {

    private DecimalRepresentation decimal;

    private final int[] positiveArguments = { 10, 50, 2500 };
    private final int[] negativeArguments = { -10, -50, -2500 };

    @BeforeAll
    void init() {
        decimal = new DecimalRepresentation();
    }

    private Stream<Arguments> createPositiveBinaryArguments() {
        return Stream.of(Arguments.of(positiveArguments[0], "1010"),
                Arguments.of(positiveArguments[1], "110010"),
                Arguments.of(positiveArguments[2], "100111000100"));
    }

    private Stream<Arguments> createNegativeBinaryArguments() {
        return Stream.of(Arguments.of(negativeArguments[0], "11111111111111111111111111110110"),
                Arguments.of(negativeArguments[1], "11111111111111111111111111001110"),
                Arguments.of(negativeArguments[2], "11111111111111111111011000111100"));
    }

    private Stream<Arguments> createPositiveOctalArguments() {
        return Stream.of(Arguments.of(positiveArguments[0], "12"),
                Arguments.of(positiveArguments[1], "62"),
                Arguments.of(positiveArguments[2], "4704"));
    }

    private Stream<Arguments> createNegativeOctalArguments() {
        return Stream.of(Arguments.of(negativeArguments[0], "37777777766"),
                Arguments.of(negativeArguments[1], "37777777716"),
                Arguments.of(negativeArguments[2], "37777773074"));
    }

    private Stream<Arguments> createPositiveHexArguments() {
        return Stream.of(Arguments.of(positiveArguments[0], "A"),
                Arguments.of(positiveArguments[1], "32"),
                Arguments.of(positiveArguments[2], "9C4"));
    }

    private Stream<Arguments> createNegativeHexArguments() {
        return Stream.of(Arguments.of(negativeArguments[0], "FFFFFFF6"),
                Arguments.of(negativeArguments[1], "FFFFFFCE"),
                Arguments.of(negativeArguments[2], "FFFFF63C"));
    }

    @ParameterizedTest
    @ValueSource(strings = { "0" })
    void shouldReturnZeroIfValueNotSpecified(String zero) {
        assertEquals(zero, decimal.toBinary());
        assertEquals(zero, decimal.toOctal());
        assertEquals(zero, decimal.toHex());
    }

    @ParameterizedTest
    @MethodSource("createPositiveBinaryArguments")
    void shouldReturnExpectedValuesForPositiveNumbersBin(int positiveNumber, String bitRepresentation) {
        decimal.setNumber(positiveNumber);
        assertEquals(bitRepresentation, decimal.toBinary());
    }

    @ParameterizedTest
    @MethodSource("createNegativeBinaryArguments")
    void shouldReturnExpectedValuesForNegativeNumbersBin(int negativeNumber, String bitRepresentation) {
        decimal.setNumber(negativeNumber);
        assertEquals(bitRepresentation, decimal.toBinary());
    }

    @ParameterizedTest
    @MethodSource("createPositiveOctalArguments")
    void shouldReturnExpectedValuesForPositiveNumbersOrc(int positiveNumber, String bitRepresentation) {
        decimal.setNumber(positiveNumber);
        assertEquals(bitRepresentation, decimal.toOctal());
    }

    @ParameterizedTest
    @MethodSource("createNegativeOctalArguments")
    void shouldReturnExpectedValuesForNegativeNumbersOct(int negativeNumber, String bitRepresentation) {
        decimal.setNumber(negativeNumber);
        assertEquals(bitRepresentation, decimal.toOctal());
    }

    @ParameterizedTest
    @MethodSource("createPositiveHexArguments")
    void shouldReturnExpectedValuesForPositiveNumbersHex(int positiveNumber, String bitRepresentation) {
        decimal.setNumber(positiveNumber);
        assertEquals(bitRepresentation, decimal.toHex());
    }

    @ParameterizedTest
    @MethodSource("createNegativeHexArguments")
    void shouldReturnExpectedValuesForNegativeNumbersHex(int negativeNumber, String bitRepresentation) {
        decimal.setNumber(negativeNumber);
        assertEquals(bitRepresentation, decimal.toHex());
    }
}

我知道我可以直接否定positiveArguments，而不是创建另一个数组，但是我想保持清楚，也许将来我会区分它们。

第二种方法:将每个转换类型组织为嵌套类。阅读有关测试的内容更清楚，但缺点是在检查/更改测试参数的情况下滚动文件/类，因为我不能使用外部类方法源(或不知道如何(？))：

@TestInstance(Lifecycle.PER_CLASS)
public class DecimalRepresentationTest {

    private DecimalRepresentation decimal;

    private final int[] positiveArguments = { 10, 50, 2500 };
    private final int[] negativeArguments = { -10, -50, -2500 };

    @BeforeAll
    void init() {
        decimal = new DecimalRepresentation();
    }

    @ParameterizedTest
    @ValueSource(strings = { "0" })
    void shouldReturnZeroIfValueNotSpecified(String zero) {
        assertEquals(zero, decimal.toBinary());
        assertEquals(zero, decimal.toOctal());
        assertEquals(zero, decimal.toHex());
    }

    @TestInstance(Lifecycle.PER_CLASS)
    @Nested
    @DisplayName("Decimal to Binary")
    class ToBinaryConversion {

        private Stream<Arguments> createPositiveBinaryArguments() {
            return Stream.of(Arguments.of(positiveArguments[0], "1010"),
                    Arguments.of(positiveArguments[1], "110010"),
                    Arguments.of(positiveArguments[2], "100111000100"));
        }

        private Stream<Arguments> createNegativeBinaryArguments() {
            return Stream.of(Arguments.of(negativeArguments[0], "11111111111111111111111111110110"),
                    Arguments.of(negativeArguments[1], "11111111111111111111111111001110"),
                    Arguments.of(negativeArguments[2], "11111111111111111111011000111100"));
        }

        @ParameterizedTest
        @MethodSource("createPositiveBinaryArguments")
        void shouldReturnExpectedValuesForPositiveNumbers(int positiveNumber, String bitRepresentation) {
            decimal.setNumber(positiveNumber);
            assertEquals(bitRepresentation, decimal.toBinary());
        }

        @ParameterizedTest
        @MethodSource("createNegativeBinaryArguments")
        void shouldReturnExpectedValuesForNegativeNumbers(int negativeNumber, String bitRepresentation) {
            decimal.setNumber(negativeNumber);
            assertEquals(bitRepresentation, decimal.toBinary());
        }
    }

    @TestInstance(Lifecycle.PER_CLASS)
    @Nested
    @DisplayName("Decimal to Octal")
    class ToOctalConversion {

        private Stream<Arguments> createPositiveOctalArguments() {
            return Stream.of(Arguments.of(positiveArguments[0], "12"),
                    Arguments.of(positiveArguments[1], "62"),
                    Arguments.of(positiveArguments[2], "4704"));
        }

        private Stream<Arguments> createNegativeOctalArguments() {
            return Stream.of(Arguments.of(negativeArguments[0], "37777777766"),
                    Arguments.of(negativeArguments[1], "37777777716"),
                    Arguments.of(negativeArguments[2], "37777773074"));
        }

        @ParameterizedTest
        @MethodSource("createPositiveOctalArguments")
        void shouldReturnExpectedValuesForPositiveNumbers(int positiveNumber, String bitRepresentation) {
            decimal.setNumber(positiveNumber);
            assertEquals(bitRepresentation, decimal.toOctal());
        }

        @ParameterizedTest
        @MethodSource("createNegativeOctalArguments")
        void shouldReturnExpectedValuesForNegativeNumbers(int negativeNumber, String bitRepresentation) {
            decimal.setNumber(negativeNumber);
            assertEquals(bitRepresentation, decimal.toOctal());
        }
    }

    @TestInstance(Lifecycle.PER_CLASS)
    @Nested
    @DisplayName("Decimal to Hexal")
    class ToHexalConversion {

        private Stream<Arguments> createPositiveHexArguments() {
            return Stream.of(Arguments.of(positiveArguments[0], "A"),
                    Arguments.of(positiveArguments[1], "32"),
                    Arguments.of(positiveArguments[2], "9C4"));
        }

        private Stream<Arguments> createNegativeHexArguments() {
            return Stream.of(Arguments.of(negativeArguments[0], "FFFFFFF6"),
                    Arguments.of(negativeArguments[1], "FFFFFFCE"),
                    Arguments.of(negativeArguments[2], "FFFFF63C"));
        }

        @ParameterizedTest
        @MethodSource("createPositiveHexArguments")
        void shouldReturnExpectedValuesForPositiveNumbers(int positiveNumber, String bitRepresentation) {
            decimal.setNumber(positiveNumber);
            assertEquals(bitRepresentation, decimal.toHex());
        }

        @ParameterizedTest
        @MethodSource("createNegativeHexArguments")
        void shouldReturnExpectedValuesForNegativeNumbers(int negativeNumber, String bitRepresentation) {
            decimal.setNumber(negativeNumber);
            assertEquals(bitRepresentation, decimal.toHex());
        }
    }
}

第三种方法:如果我要进行第二种方法，为每个测试用例创建新的参数方法是没有意义的，所以我决定将它们作为@CsvSource (因为只有-常量的注释参数，所以必须在数组之外初始化参数)：

@TestInstance(Lifecycle.PER_CLASS)
public class DecimalRepresentationTest {

    private DecimalRepresentation decimal;

    static private final String POSITIVE_A = "10", POSITIVE_B = "50", POSITIVE_C = "2500"; 
    static private final String NEGATIVE_A = "-10", NEGATIVE_B = "-50", NEGATIVE_C = "-2500";   

    @BeforeAll
    void init() {
        decimal = new DecimalRepresentation();
    }

    @ParameterizedTest
    @ValueSource(strings = "0")
    void shouldReturnZeroIfValueNotSpecified(String zero) {
        assertEquals(zero, decimal.toBinary());
        assertEquals(zero, decimal.toOctal());
        assertEquals(zero, decimal.toHex());
    }

    @TestInstance(Lifecycle.PER_CLASS)
    @Nested
    @DisplayName("Decimal to Binary")
    class ToBinaryConversion {

        @ParameterizedTest
        @CsvSource({"'" + POSITIVE_A + "', 1010",
                    "'" + POSITIVE_B + "', 110010",
                    "'" + POSITIVE_C + "', 100111000100"})
        void shouldReturnExpectedValuesForPositiveNumbers(int positiveNumber, String bitRepresentation) {
            decimal.setNumber(positiveNumber);
            assertEquals(bitRepresentation, decimal.toBinary());
        }

        @ParameterizedTest
        @CsvSource({"'" + NEGATIVE_A + "', 11111111111111111111111111110110",
                    "'" + NEGATIVE_B + "', 11111111111111111111111111001110",
                    "'" + NEGATIVE_C + "', 11111111111111111111011000111100"})
        void shouldReturnExpectedValuesForNegativeNumbers(int negativeNumber, String bitRepresentation) {
            decimal.setNumber(negativeNumber);
            assertEquals(bitRepresentation, decimal.toBinary());
        }
    }

    @TestInstance(Lifecycle.PER_CLASS)
    @Nested
    @DisplayName("Decimal to Octal")
    class ToOctalConversion {

        @ParameterizedTest
        @CsvSource({"'" + POSITIVE_A + "', 12",
                    "'" + POSITIVE_B + "', 62",
                    "'" + POSITIVE_C + "', 4704"})
        void shouldReturnExpectedValuesForPositiveNumbers(int positiveNumber, String bitRepresentation) {
            decimal.setNumber(positiveNumber);
            assertEquals(bitRepresentation, decimal.toOctal());
        }

        @ParameterizedTest
        @CsvSource({"'" + NEGATIVE_A + "', 37777777766",
                    "'" + NEGATIVE_B + "', 37777777716",
                    "'" + NEGATIVE_C + "', 37777773074"})
        void shouldReturnExpectedValuesForNegativeNumbers(int negativeNumber, String bitRepresentation) {
            decimal.setNumber(negativeNumber);
            assertEquals(bitRepresentation, decimal.toOctal());
        }
    }

    @TestInstance(Lifecycle.PER_CLASS)
    @Nested
    @DisplayName("Decimal to Hexal")
    class ToHexalConversion {

        @ParameterizedTest
        @CsvSource({"'" + POSITIVE_A + "', A",
                    "'" + POSITIVE_B + "', 32",
                    "'" + POSITIVE_C + "', 9C4"})
        void shouldReturnExpectedValuesForPositiveNumbers(int positiveNumber, String bitRepresentation) {
            decimal.setNumber(positiveNumber);
            assertEquals(bitRepresentation, decimal.toHex());
        }

        @ParameterizedTest
        @CsvSource({"'" + NEGATIVE_A + "', FFFFFFF6",
                    "'" + NEGATIVE_B + "', FFFFFFCE",
                    "'" + NEGATIVE_C + "', FFFFF63C"})
        void shouldReturnExpectedValuesForNegativeNumbers(int negativeNumber, String bitRepresentation) {
            decimal.setNumber(negativeNumber);
            assertEquals(bitRepresentation, decimal.toHex());
        }
    }
}

你怎么看出来的？在这种情况下我应该用哪一种？顺便说一句，当我测试一些像我的自定义数字系统转换器时，我能完全信任标准Java，而不是硬编码预期的结果，只使用Integer.toString(int i，int基)方法吗？

java

unit-testing

junit5

回答 1

Stack Overflow用户

发布于 2017-12-09 22:34:32

我建议的一般准则是：

让每个测试测试一件事。如果测试中有多个断言，那么如果第一个断言失败，则永远不知道后面的断言是否也失败--通过拥有多个断言，您就隐藏了潜在检测其他错误的机会。
让每个测试站都是独立的，这样您就不必依赖测试的顺序。当您只想重新运行失败的测试时，这是很有帮助的。
是的，您应该依赖标准的Java类来执行他们所说的操作。为他们编写单元测试将比您需要做的工作更多(基本上，如果他们不按他们说的做，我们都会受到影响--因此他们更好；他们也比您可能编写的任何测试都经过了更彻底的测试)。
让测试简单明了(应用“吻”原则，保持简单-简单-莎莉)

我意识到这并不能直接解决您的代码布局问题，但是它可能会帮助您做出一些决定。

票数 0

页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持

原文链接：

https://stackoverflow.com/questions/47551271

复制

相似问题

问Junit 5测试类结构
EN

回答 1

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Junit 5测试类结构EN

回答 1

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Junit 5测试类结构
EN