1.原理图
2. 基本架构
被测代码
package com.jerry; public class Calculator{ private static int result; public void add(int n) { result = result + n; } public void substract(int n) { result = result - n; } public void multiply(int n) { result = result * n; } public void divide(int n){ try { result = result / n; }catch(ArithmeticException ex){ System.out.println(ex); throw new ArithmeticException("The n not allowed to 0!!") } } }
最基本的测试代码
public class CalculatorTest { private static Calculator calculator = new Calculator(); @BeforeEach public void setUp() throws Exception { calculator.clear(); } @Test @DisplayName("测试加法") public void testAdd() { calculator.add(2); calculator.add(3); assertEquals(5, calculator.getResult()); } @Test @DisplayName("测试减法") public void testSubstract() { calculator.add(5); calculator.substract(3); Assertions.assertEquals(2, calculator.getResult()); } @Test @DisplayName("测试乘法") public void testMultiply() { calculator.add(3); calculator.multiply(2); Assertions.assertEquals(6, calculator.getResult()); } @Test @DisplayName("测试除法") public void testDivide() { calculator.add(9); calculator.divide(3); Assertions.assertEquals(3, calculator.getResult()); }
标签@DisplayName可以在测试结果的时候显示其内容。
3．JUnit5的修饰符
修饰符 |
含义 |
@DisplayName |
为测试类或者测试方法设置展示名称 |
@BeforeAll |
表示在所有单元测试之前执行 |
@AfterAll |
表示在所有单元测试之后执行 |
@BeforeEach |
表示在每个单元测试之前执行 |
@AfterEach |
表示在每个单元测试之后执行 |
@Disabled |
表示测试类或测试方法不执行，类似于JUnit4中的@Ignore |
@Timeout |
表示测试方法运行如果超过了指定时间将会返回错误，类似于JUnit4中的(timeout=XXX) JUnit 5.5.2以后 |
@RepeatedTest |
表示方法可重复执行 |
@ParameterizedTest |
表示方法是参数化测试，类似于JUnit4中的@RunWith(Parameterized.class) |
@Tag |
表示单元测试类别，类似于JUnit4中的@Categories |
@ExtendWith |
为测试类或测试方法提供扩展类引用 |
描述装饰符的程序
package com.jerry; import static org.junit.jupiter.api.Assertions.assertAll; import org.junit.jupiter.api.*; public class MyFirstJunit5Test { @BeforeAll @DisplayName("每条用例开始时执行") public static void startALL(){ System.out.println("BeforeAll"); } @AfterAll @DisplayName("每条用例开始时执行") public static void endAll(){ System.out.println("AfterAll"); } @BeforeEach @DisplayName("每条用例开始时执行") void start(){ System.out.println("BeforeEach"); } @AfterEach @DisplayName("每条用例结束时执行") void end(){ System.out.println("AfterEach"); } @Test void myFirstTest() { System.out.println("myFirstTest"); Assertions.assertEquals(2, 1 + 1); } @Test @DisplayName("描述测试用例") void testWithDisplayName() { System.out.println("testWithDisplayName"); } @Test @Disabled("这条用例暂时跑不过，忽略!") void myFailTest(){ System.out.println("Disabled Testcase"); Assertions.assertEquals(1,2); } @Test @DisplayName("运行一组断言") public void assertAllCase() { System.out.println("运行一组断言"); assertAll("groupAssert", () -> Assertions.assertEquals(2, 1 + 1), () -> Assertions.assertTrue(1 > 0) ); } @Test @DisplayName("依赖注入1") public void testInfo(final TestInfo testInfo) { System.out.println(testInfo.getDisplayName()); } @Test @DisplayName("依赖注入2") public void testReporter(final TestReporter testReporter) { testReporter.publishEntry("name", "Alex"); } }
运行结果（缩进为了看起来方便，我自己设置的）
BeforeAll BeforeEach 依赖注入1 AfterEach BeforeEach TestIdentifier [依赖注入2] ReportEntry [timestamp = 2020-08-21T11:38:49.361976500, name = 'Alex’] AfterEach BeforeEach myFirstTest AfterEach BeforeEach testWithDisplayName AfterEach BeforeEach 运行一组断言 AfterEach AfterAll
注意：@BeforeAll、 @AfterALL注解方法必须是静态方法，否则会抛出运行时错误。
4. JUnit5 新加断言
断言方法 |
断言描述 |
assertTimeoutPreemptively |
超时断言 |
assertThrows |
异常断言 |
5. 异常断言
被测的程序
public void divide(int n){ try { result = result / n; }catch(ArithmeticException ex){ System.out.println(ex); throw new ArithmeticException("The n not allowed to 0!!"); } }
测试程序
@Test @DisplayName("测试除0异常") public void testDivideByZero() { calculator.add(9); Throwable exception = Assertions.assertThrows(ArithmeticException.class, () -> calculator.divide(0)); Assertions.assertEquals("The n not allowed to 0!!",exception.getMessage()); }
6. 超时断言
@Test public void squareRoot() { Assertions.assertTimeoutPreemptively(Duration.of(2, ChronoUnit.SECONDS), () -> calculator.squareRoot(4)) }
判断程序是否应该在两秒钟执行完毕。类似于JUnit4中的(timeout=XXX)。
7. 参数化测试
7.1单参数
@ParameterizedTest @ValueSource(ints = {1,2,3,4}) @DisplayName("参数化测试_单参数") public void parameterizedTest(int param) { calculator.add(param); calculator.add(-1 * param); Assertions.assertEquals(0, calculator.getResult()); }
标签：
- @ValueSource: 为参数化测试指定入参来源，支持八大基础类以及String类型,Class类型
- @NullSource: 表示为参数化测试提供一个null的入参
- @EnumSource: 表示为参数化测试提供一个枚举入参
ValueSource类型：
- String values: @ValueSource(strings = {"foo", "bar", "baz"})
- Double values: @ValueSource(doubles = {1.5D, 2.2D, 3.0D})
- Long values: @ValueSource(longs = {2L, 4L, 8L})
- Integer values: @ValueSource(ints = {2, 4, 8})
7.2 Enum参数
import java.util.concurrent.TimeUnit; … @ParameterizedTest @EnumSource(value = TimeUnit.class, names = {"SECONDS", "MINUTES"}) @DisplayName("参数化测试_Enum参数") void testTimeUnitJustSecondsAndMinutes(TimeUnit unit) { Assertions.assertTrue(EnumSet.of(TimeUnit.SECONDS, TimeUnit.MINUTES).contains(unit)); Assertions.assertFalse(EnumSet .of(TimeUnit.DAYS, TimeUnit.HOURS, TimeUnit.MILLISECONDS, TimeUnit.NANOSECONDS, TimeUnit.MICROSECONDS).contains(unit)); }
7.3参数化测试——方法参数(多参数)
注意：这个方法返回必须是个流 @ParameterizedTest @MethodSource("paramGenerator") @DisplayName("参数化测试_ 方法参数(多参数)") void MethodParameForSquareRoot(int param, int result){ calculator.squareRoot(param); Assertions.assertEquals(result, calculator.getResult()); } static Stream<Arguments> paramGenerator(){ return Stream.of(Arguments.of(4,2), Arguments.of(9,3), Arguments.of(16,4)); }
7.4.参数化测试——CVS文件参数
@ParameterizedTest @CsvFileSource(resources = "data.csv") //指定csv文件位置 @DisplayName("参数化测试-csv文件") public void parameterizedCVSFile(int param, int result) { calculator.squareRoot(param); Assertions.assertEquals(result, calculator.getResult()); }
其中，data.csv为：
4 2 9 3 16 4
8.内嵌测试类
一般一个产品类对应一个测试类，但是使用JUnit，可以实现类的嵌套。
package com.jerry; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; public class NestedTestDemo { @Test @DisplayName("Nested") void isInstantiatedWithNew() { System.out.println("最一层--内嵌单元测试"); } @Nested @DisplayName("Nested2") class Nested2 { @BeforeEach void Nested2_init() { System.out.println("Nested2_init"); } @Test void Nested2_test() { System.out.println("第二层-内嵌单元测试"); } @Nested @DisplayName("Nested3") class Nested3 { @BeforeEach void Nested3_init() { System.out.println("Nested3_init"); } @Test void Nested3_test() { System.out.println("第三层-内嵌单元测试"); } } } }
结果输出：
第一层--内嵌单元测试 Nested2_init 第二层-内嵌单元测试 Nested2_init Nested3_init 第三层-内嵌单元测试
9. 重复测试
@RepeatedTest(5) //表示重复执行5次 @DisplayName("重复减法") public void testSubstractManyTimes() { calculator.add(5); calculator.substract(3); Assertions.assertEquals(2, calculator.getResult()); }
这个测试用例将被执行5次，为什么设计这个方法，我个人没有理解。
10. 动态测试
TestFactory @DisplayName("动态测试") Iterator<DynamicTest> dynamicTests() { return Arrays.asList( dynamicTest("第1个动态测试", () ->{calculator.squareRoot(4);Assertions.assertEquals(2, calculator.getResult());}), dynamicTest("第2个动态测试", () ->{calculator.squareRoot(9);Assertions.assertEquals(3, calculator.getResult());}), dynamicTest("第3个动态测试", () ->{calculator.squareRoot(16);Assertions.assertEquals(4, calculator.getResult());}), dynamicTest("第4个动态测试", () ->{calculator.squareRoot(25);Assertions.assertEquals(5, calculator.getResult());}) ).iterator(); }
动态测试用得比较少，这个功能的原因我个人也不太理解。
11分组断言assertAll
@Test @DisplayName("开根号分组断言") public void testGroup() { int[] parem = {4, 9, 16, 25, 36}; int[] result ={2, 3, 4, 5, 6}; Assertions.assertAll("parem,result", () -> {calculator.squareRoot(parem[0]);Assertions.assertEquals(result[0], calculator.getResult());}, () -> {calculator.squareRoot(parem[1]);Assertions.assertEquals(result[1], calculator.getResult());}, () -> {calculator.squareRoot(parem[2]);Assertions.assertEquals(result[2], calculator.getResult());}, () -> {calculator.squareRoot(parem[3]);Assertions.assertEquals(result[3], calculator.getResult());}, () -> {calculator.squareRoot(parem[4]);Assertions.assertEquals(result[4], calculator.getResult());} );
分组断言中任一个断言的失败，都会将以 MultipleFailuresError 错误进行抛出提示。另外可以看出，使用分组断言也可以实现参数化
