基本的注解都是方法上的注解，意思就是只在测试方法上进行添加，对应注解有以下几种：

注解 说明
@Test 测试方法的入口;可单独运行
@BeforeEach 每个测试方法前运行;不可以单独运行该方法
@AfterEach 每个测试方法后运行;不可以单独运行该方法
@BeforeAll 在类中所有方法前运行;static修饰;不可单独运行该方法
@AfterAll 在类中所有方法后运行;static修饰;不可单独运行该方法

对应业务代码如下：

  1. package top.testeru;
  3. import org.slf4j.Logger;
  5. import java.util.Arrays;
  6. import java.util.UUID;
  7. import java.util.stream.IntStream;
  9. import static java.lang.invoke.MethodHandles.lookup;
  10. import static org.slf4j.LoggerFactory.getLogger;
  12. /**
  13.  * @program: tutorials
  14.  * @author: testeru.top
  15.  * @description: 我的被测系统软件
  16.  * @Version 1.0
  17.  * @create: 2022/1/17 4:58 下午
  18.  */
  19. public class MySUT {
  20.     //获得具有所需名称的记录器
  21.     static final Logger logger = getLogger(lookup().lookupClass());
  23.     //用例名
  24.     String name;
  25.     //唯一ID标识
  26.     String id;
  29.     public String getName() {
  30.         return name;
  31.     }
  33.     public void setName(String name) {
  34.         this.name = name;
  35.     }
  37.     public String getId() {
  38.         return id;
  39.     }
  41.     public void setId(String id) {
  42.         this.id = id;
  43.     }
  45.     public MySUT(String name) {
  46.         this.name = name;
  47.         logger.info("Open {} ", name);
  48.     }
  51.     public void initId(){
  52.         id = UUID.randomUUID().toString();
  53.         logger.info("Generate ID：{} ", id);
  55.     }
  56.     public void destroyId() {
  57.         if (id == null) {
  58.             throw new IllegalArgumentException(name + " 没有初始化对应ID");
  59.         }
  60.         logger.info("Release ID: {} ", id);
  61.         id = null;
  62.     }
  65.     public void close() {
  66.         logger.info("Close {} ", name);
  67.     }
  71.     //连续添加
  73.     public int sum(int... numbers) {
  75.         if(Arrays.stream(numbers).anyMatch(u -> u > 99) | Arrays.stream(numbers).anyMatch(u -> u < -99)){
  76.             // 请输入范围内的整数
  77.             logger.warn("Please enter an integer in the range");
  78.             throw new IllegalArgumentException("Please enter an integer in the range！");
  79.         }else {
  80.             return IntStream.of(numbers).sum();
  81.         }
  83.     }
  86.     //从100进行减法
  87.     public int subtract(int... numbers) {
  88.         if(Arrays.stream(numbers).anyMatch(u -> u > 99) | Arrays.stream(numbers).anyMatch(u -> u < -99)){
  89.             logger.warn("请输入范围内的整数");
  90.             throw new IllegalArgumentException("请输入范围内的整数！");
  91.         }else {
  92.             return IntStream.of(numbers).reduce(100, (a, b) -> a-b);
  93.         }
  94.     }
  96.     public int subtract(int x,int y) {
  97.         if(x>99 | x<-99 | y>99 | y<-99){
  98.             logger.warn("请输入范围内的整数");
  99.             throw new IllegalArgumentException("请输入范围内的整数！");
  100.         }else {
  101.             return x-y;
  103.         }
  104.     }
  107.     //平均值 average
  108.     public double average(int... numbers) {
  109.         if(Arrays.stream(numbers).anyMatch(u -> u > 99) | Arrays.stream(numbers).anyMatch(u -> u < -99)){
  110.             logger.warn("请输入范围内的整数");
  111.             throw new IllegalArgumentException("请输入范围内的整数！");
  112.         }else {
  113.             return IntStream.of(numbers).average().getAsDouble();
  114.         }
  115.     }
  119.     //连续拼接
  120.     public String concatStr(String... words) {
  121.         return String.join(" ", words);
  122.     }
  126. }

@Test

我们首先来看第一个注解，是Test注解。这个注解放在方法上，对应的方法就称为测试方法。并且该测试方法可以直接运行，在Idea中可以看到添加完@Test注解后，对应的左边出现了可运行的绿色按钮，点击该按钮就可运行对应的方法。

我们可以把它看作一个类似Java中main方法的入口，但是又和main方法有区别，对应的一个Java类中只能有一个main方法，但是@Test注解可以在一个Java类中有多个。

同样由于对应的和main方法类似，都是没有返回值「void」的方法。

总结以上内容就是如下四点：

  • 可直接运行
  • 一个类里可以有多个
  • 类似main方法入口
  • @Test注解的方法没有返回值，void

assertEquals

在这里我们首先要简单介绍一个junit5自带的一个基本断言，就是assertEquals。该断言只是判断传入的期望值和实际值是否完全一样，如果不一样，则报错，如果message有内容，报错就是message的描述信息。

assertEquals(expected, actual,message)里面最少是2个参数，一个自己的期望值「expected」,一个程序的实际值「 actual」。如果想要断言失败的情况下显示自定义的说明，则加上第3个参数，即断言失败说明「message」。

  • assertEquals(expected, actual,message)
  • 断言「判断」预期的内容和实际的内容是否相等
    • expected
      • 期望值
    • actual
      • 代码业务逻辑的实际值
    • message
      • 断言失败的时候显示说明

代码块

  1. package top.testeru.basic;  
  3. import top.testeru.MySUT;  
  4. import org.junit.jupiter.api.Test;  
  5. import org.slf4j.Logger;  
  7. import static java.lang.invoke.MethodHandles.lookup;  
  8. import static org.junit.jupiter.api.Assertions.*;  
  9. import static org.slf4j.LoggerFactory.getLogger;  
  11. /**  
  12.  * @program: tutorials  
  13.  * @author: testeru.top
  14.  * @description: 基本注解「方法注解」测试  
  15.  * 加法测试用例「正常、边界值、超出边界值」  
  16.  * @Version 1.0  
  17.  * @create: 2022/1/17 5:01 下午  
  18.  */  
  19. public class BasicAnnotation1sTest {  
  20.     static final Logger logger = getLogger(lookup().lookupClass());  
  21.     @Test  
  22.      void addTest1(){  
  23.         MySUT mySUT = new MySUT("Calculator");  
  24.         logger.info("Begin Add Test");  
  25.         //加法运算  
  26.         int sum = mySUT.sum(5, 8);  
  27.         logger.info("Addition result：{}",sum);  
  28.         // expected:期望值,  actual:运算的实际值  
  29.         assertEquals(13,sum);  
  30.     }  
  31.     @Test  
  32.      void addTest2(){  
  33.         MySUT mySUT = new MySUT("Calculator");  
  34.         logger.info("Begin Add Test");  
  35.         //加法运算  
  36.         int sum = mySUT.sum(99, -98);  
  37.         logger.info("Addition result：{}",sum);  
  38.         // expected:期望值,  actual:运算的实际值  
  39.         assertEquals(1,sum);  
  40.     }  
  41.     @Test  
  42.      void addTest3(){  
  43.         MySUT mySUT = new MySUT("Calculator");  
  44.         logger.info("Begin Add Test");  
  45.         //加法运算  
  46.         int sum = mySUT.sum(100, -98);  
  47.         logger.info("Addition result：{}",sum);  
  48.         // expected:期望值,  actual:运算的实际值  
  49.         assertEquals(0,sum);
  50.     }  
  51. }

一」基本的注解、断言 - 图1

这个时候发现，对应的超出边界值不能进行断言校验，甚至是相关的业务逻辑都无法进行，那我们应该怎么办呢？

这个时候我们就需要用到下面的assertThrows来处理代码抛出异常的断言：

assertThrows

assertThrows去判断代码抛出的异常是业务代码自定义的异常不，对应的期望值变成了异常类型「Class<T>」的期望值，实际的值也是抛出异常的实际值「Executable」，同样如果想要断言失败的情况下显示自定义的说明，则加上第3个参数，即断言失败说明「message」。

  • assertThrows(Class<T> expectedType, Executable executable, String message)
  • 断言提供的业务逻辑的执行是否会引发预期类型的异常并返回异常对象。
    • expectedType
      • 报错的类型的类
    • executable
      • 执行的业务流
    • message
      • 断言失败的时候显示说明
  1. @Test
  2. void addTest3(){  
  3.     MySUT mySUT = new MySUT("Calculator");  
  4.     logger.info("Begin Add Test");  
  5.     /*  
  6.  //加法运算  
  7.  int sum = mySUT.sum(100, -98); logger.info("Addition result：{}",sum);  
  8.  // expected:期望值,  actual:运算的实际值  
  9.  assertEquals(0,sum); */ Exception illegalArgumentException = assertThrows(IllegalArgumentException.class, () ->  
  10.             mySUT.sum(100, -98));  
  11.     assertTrue(illegalArgumentException.getMessage().contains("enter an integer in the range"));  
  12. }

一」基本的注解、断言 - 图2

@BeforeEach

这个注解同样也是放在方法上，对应的也是一个没有返回值「void」的方法，和Test注解不同的是，在方法上添加了该注解可以看到对应idea左边没有运行的按钮，说明这个注解对应的方法是不可以单独的运行。

既然这个注解对应的方法不能单独运行，那对应的应该在什么时候运行呢？
该注解的方法其实是在每个@Test注解方法前面运行。既然知道了什么时候运行，那这个注解有什么作用呢？一般什么情况下我们才会用到这个注解呢？

这个主要就是看大家的业务需求了，比如我们目前这个测试系统，那我可以把生成ID放在每个测试方法之前进行生成， 这个是一个重复的代码，那我们就可以把它提取到@BeforeEach这个注解对应的方法内去运行，以减少我们的重复代码量。

总结

总结为以下三点：

  • 不可单独运行，需要运行测试类/方法
  • 在每一个test()前运行
  • @BeforeEach注解的方法没有返回值，void

示例

对应示例代码：

  1. package top.testeru.basic;
  3. import top.testeru.MySUT;
  4. import org.junit.jupiter.api.*;
  5. import org.slf4j.Logger;
  7. import static java.lang.invoke.MethodHandles.lookup;
  8. import static org.junit.jupiter.api.Assertions.*;
  9. import static org.slf4j.LoggerFactory.getLogger;
  11. /**
  12.  * @program: tutorials
  13.  * @author: testeru.top
  14.  * @description: 基本注解「方法注解」测试
  15.  * 加法测试用例「正常、边界值、超出边界值」
  16.  * 减法测试用例「正常」
  17.  * @Version 1.0
  18.  * @create: 2022/1/17 5:01 下午
  19.  */
  20. public class BasicAnnotation2Test {
  21.     static final Logger logger = getLogger(lookup().lookupClass());
  23.     MySUT mySUT = new MySUT("Calculator");;
  25.     @BeforeEach
  26.     void beforeEach() {
  27.         mySUT.initId();
  28.     }
  30.     @Test
  31.     void addTest1(){
  32.         logger.info("Begin Add Test");
  33.         //加法运算
  34.         int sum = mySUT.sum(5, 8);
  35.         //所有的统称为运算结果
  36.         logger.info("Operation result：{}",sum);
  37.         // expected:期望值,  actual:运算的实际值
  38.         assertEquals(13,sum);
  39.     }
  43.     @Test
  44.     void addTest2(){
  45.         MySUT mySUT = new MySUT("Calculator");
  46.         logger.info("Begin Add Test");
  47.         //加法运算
  48.         int sum = mySUT.sum(99, -98);
  49.         logger.info("Addition result：{}",sum);
  50.         // expected:期望值,  actual:运算的实际值
  51.         assertEquals(1,sum);
  52.     }
  53.     @Test
  54.     void addTest3(){
  55.         logger.info("Begin Add Test");
  56.         //超过边界值的加法运算
  57.         Exception illegalArgumentException = assertThrows(IllegalArgumentException.class, () -> mySUT.sum(100, -98));
  58.         // expected:期望值,  actual:运算的实际值
  59.         assertTrue(illegalArgumentException.getMessage().contains("enter an integer in the range"));
  61.     }
  62.     @Test
  63.     void subtractTest1(){
  64.         logger.info("Begin Subtract Test");
  65.         //减法运算
  66.         int subtract = mySUT.subtract(5, 8);
  67.         logger.info("Operation result：{}",subtract);
  68.         // expected:期望值,  actual:运算的实际值
  69.         assertEquals(-3,subtract);
  70.     }
  72. }

结果显示：

  2. 2022-02-09 14:04:22 [main] INFO  top.testeru.MySUT.<init>(47) -- Open Calculator 
  3. 2022-02-09 14:04:22 [main] INFO  top.testeru.MySUT.initId(53) -- Generate ID：3b732a76-19e2-4a60-8a34-2b9795894875 
  4. 2022-02-09 14:04:22 [main] INFO  t.testeru.basic.BasicAnnotation2Test.subtractTest1(72) -- Begin Subtract Test
  5. 2022-02-09 14:04:22 [main] INFO  t.testeru.basic.BasicAnnotation2Test.subtractTest1(75) -- Operation result：-3
  6. 2022-02-09 14:04:22 [main] INFO  top.testeru.MySUT.initId(53) -- Generate ID：69ec586b-6346-4940-8ff9-e06156692975 
  7. 2022-02-09 14:04:22 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest1(40) -- Begin Add Test
  8. 2022-02-09 14:04:22 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest1(44) -- Operation result：13
  9. 2022-02-09 14:04:22 [main] INFO  top.testeru.MySUT.initId(53) -- Generate ID：0f484eab-7790-473e-a7ba-998ca3a84c5d 
  10. 2022-02-09 14:04:22 [main] INFO  top.testeru.MySUT.<init>(47) -- Open Calculator 
  11. 2022-02-09 14:04:22 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest2(54) -- Begin Add Test
  12. 2022-02-09 14:04:22 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest2(57) -- Addition result：1
  13. 2022-02-09 14:04:22 [main] INFO  top.testeru.MySUT.initId(53) -- Generate ID：a62e3eff-a172-403b-a4b2-bae6fb4b16f2 
  14. 2022-02-09 14:04:22 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest3(63) -- Begin Add Test
  15. 2022-02-09 14:04:22 [main] WARN  top.testeru.MySUT.sum(77) -- Please enter an integer in the range

@AfterEach

  • 不可单独运行，需要运行测试类/方法
  • 在每一个test()后运行
  • @AfterEach注解的方法没有返回值，void
  1. package top.testeru.basic;
  3. import top.testeru.MySUT;
  4. import org.junit.jupiter.api.*;
  5. import org.slf4j.Logger;
  7. import static java.lang.invoke.MethodHandles.lookup;
  8. import static org.junit.jupiter.api.Assertions.*;
  9. import static org.slf4j.LoggerFactory.getLogger;
  11. /**
  12.  * @program: tutorials
  13.  * @author: testeru.top
  14.  * @description: 基本注解「方法注解」测试
  15.  * 加法测试用例「正常、边界值、超出边界值」
  16.  * 减法测试用例「正常」
  17.  * @Version 1.0
  18.  * @create: 2022/1/17 5:01 下午
  19.  */
  20. public class BasicAnnotation2Test {
  21.     static final Logger logger = getLogger(lookup().lookupClass());
  22.     MySUT mySUT = new MySUT("Calculator");
  23.     @BeforeEach
  24.     void beforeEach() {
  25.         mySUT.initId();
  26.     }
  27.     @Test
  28.     void addTest1(){
  29.         logger.info("Begin Add Test");
  30.         //加法运算
  31.         int sum = mySUT.sum(5, 8);
  32.         //所有的统称为运算结果
  33.         logger.info("Operation result：{}",sum);
  34.         // expected:期望值,  actual:运算的实际值
  35.         assertEquals(13,sum);
  36.     }
  37.     @Test
  38.     void addTest2(){
  39.         MySUT mySUT = new MySUT("Calculator");
  40.         logger.info("Begin Add Test");
  41.         //加法运算
  42.         int sum = mySUT.sum(99, -98);
  43.         logger.info("Addition result：{}",sum);
  44.         // expected:期望值,  actual:运算的实际值
  45.         assertEquals(1,sum);
  46.     }
  47.     @Test
  48.     void addTest3(){
  49.         logger.info("Begin Add Test");
  50.         //超过边界值的加法运算
  51.         Exception illegalArgumentException = assertThrows(IllegalArgumentException.class, () -> mySUT.sum(100, -98));
  52.         // expected:期望值,  actual:运算的实际值
  53.         assertTrue(illegalArgumentException.getMessage().contains("enter an integer in the range"));
  54.     }
  55.     @Test
  56.     void subtractTest1(){
  57.         logger.info("Begin Subtract Test");
  58.         //减法运算
  59.         int subtract = mySUT.subtract(5, 8);
  60.         logger.info("Operation result：{}",subtract);
  61.         // expected:期望值,  actual:运算的实际值
  62.         assertEquals(-3,subtract);
  63.     }
  64.     @AfterEach
  65.     void afterEach() {
  66.         mySUT.destroyId();
  67.     }
  68. }

结果显示：

  1. 2022-02-09 14:08:50 [main] INFO  top.testeru.MySUT.<init>(47) -- Open Calculator 
  2. 2022-02-09 14:08:50 [main] INFO  top.testeru.MySUT.initId(53) -- Generate ID：cbc27682-5e33-428c-af48-defa925b657d 
  3. 2022-02-09 14:08:50 [main] INFO  t.testeru.basic.BasicAnnotation2Test.subtractTest1(72) -- Begin Subtract Test
  4. 2022-02-09 14:08:50 [main] INFO  t.testeru.basic.BasicAnnotation2Test.subtractTest1(75) -- Operation result：-3
  5. 2022-02-09 14:08:50 [main] INFO  top.testeru.MySUT.destroyId(60) -- Release ID: cbc27682-5e33-428c-af48-defa925b657d 
  6. 2022-02-09 14:08:50 [main] INFO  top.testeru.MySUT.<init>(47) -- Open Calculator 
  7. 2022-02-09 14:08:50 [main] INFO  top.testeru.MySUT.initId(53) -- Generate ID：b9f6d56e-ee62-45e8-b6d9-d496975191d0 
  8. 2022-02-09 14:08:50 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest1(40) -- Begin Add Test
  9. 2022-02-09 14:08:50 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest1(44) -- Operation result：13
  10. 2022-02-09 14:08:50 [main] INFO  top.testeru.MySUT.destroyId(60) -- Release ID: b9f6d56e-ee62-45e8-b6d9-d496975191d0 
  11. 2022-02-09 14:08:50 [main] INFO  top.testeru.MySUT.<init>(47) -- Open Calculator 
  12. 2022-02-09 14:08:50 [main] INFO  top.testeru.MySUT.initId(53) -- Generate ID：bdea4c25-260b-4d40-b9b0-9b49a8887c37 
  13. 2022-02-09 14:08:50 [main] INFO  top.testeru.MySUT.<init>(47) -- Open Calculator 
  14. 2022-02-09 14:08:50 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest2(54) -- Begin Add Test
  15. 2022-02-09 14:08:50 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest2(57) -- Addition result：1
  16. 2022-02-09 14:08:50 [main] INFO  top.testeru.MySUT.destroyId(60) -- Release ID: bdea4c25-260b-4d40-b9b0-9b49a8887c37 
  17. 2022-02-09 14:08:50 [main] INFO  top.testeru.MySUT.<init>(47) -- Open Calculator 
  18. 2022-02-09 14:08:50 [main] INFO  top.testeru.MySUT.initId(53) -- Generate ID：f81b4ace-02cf-48c2-b590-2ddcbca25823 
  19. 2022-02-09 14:08:50 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest3(63) -- Begin Add Test
  20. 2022-02-09 14:08:50 [main] WARN  top.testeru.MySUT.sum(77) -- Please enter an integer in the range
  21. 2022-02-09 14:08:50 [main] INFO  top.testeru.MySUT.destroyId(60) -- Release ID: f81b4ace-02cf-48c2-b590-2ddcbca25823
  • 每次计算完都释放ID

@BeforeAll 

  2. MySUT mySUT ;
  4. @BeforeAll
  5. void beforeAll() {
  6.     mySUT = new MySUT("计算器");
  7. }

报错信息：

  1. org.junit.platform.commons.JUnitException: @BeforeAll method 'void com.testeru.base.BasicAnnotation2Test.beforeAll()' must be static unless the test class is annotated with @TestInstance(Lifecycle.PER_CLASS).
  • 对应@BeforeAll需要static关键字修饰
  • 不可单独运行，需要运行测试类/方法
  • 在所有的方法前运行，包含BeforeEach
  • @BeforeAll注解的方法没有返回值，void
  1. package top.testeru.basic;
  3. import top.testeru.MySUT;
  4. import org.junit.jupiter.api.*;
  5. import org.slf4j.Logger;
  7. import static java.lang.invoke.MethodHandles.lookup;
  8. import static org.junit.jupiter.api.Assertions.*;
  9. import static org.slf4j.LoggerFactory.getLogger;
  11. /**
  12.  * @program: tutorials
  13.  * @author: testeru.top
  14.  * @description: 基本注解「方法注解」测试
  15.  * 加法测试用例「正常、边界值、超出边界值」
  16.  * 减法测试用例「正常」
  17.  * @Version 1.0
  18.  * @create: 2022/1/17 5:01 下午
  19.  */
  20. public class BasicAnnotation2Test {
  21.     static final Logger logger = getLogger(lookup().lookupClass());
  22.     static MySUT mySUT ;
  23.     @BeforeAll
  24.     static void beforeAll() {
  25.         mySUT = new MySUT("Calculator");
  26.     }
  27.     @BeforeEach
  28.     void beforeEach() {
  29.         mySUT.initId();
  30.     }
  31.     @Test
  32.     void addTest1(){
  33.         logger.info("Begin Add Test");
  34.         //加法运算
  35.         int sum = mySUT.sum(5, 8);
  36.         //所有的统称为运算结果
  37.         logger.info("Operation result：{}",sum);
  38.         // expected:期望值,  actual:运算的实际值
  39.         assertEquals(13,sum);
  40.     }
  41.     @Test
  42.     void addTest2(){
  43.         MySUT mySUT = new MySUT("Calculator");
  44.         logger.info("Begin Add Test");
  45.         //加法运算
  46.         int sum = mySUT.sum(99, -98);
  47.         logger.info("Addition result：{}",sum);
  48.         // expected:期望值,  actual:运算的实际值
  49.         assertEquals(1,sum);
  50.     }
  51.     @Test
  52.     void addTest3(){
  53.         logger.info("Begin Add Test");
  54.         //超过边界值的加法运算
  55.         Exception illegalArgumentException = assertThrows(IllegalArgumentException.class, () -> mySUT.sum(100, -98));
  56.         // expected:期望值,  actual:运算的实际值
  57.         assertTrue(illegalArgumentException.getMessage().contains("enter an integer in the range"));
  59.     }
  60.     @Test
  61.     void subtractTest1(){
  62.         logger.info("Begin Subtract Test");
  63.         //减法运算
  64.         int subtract = mySUT.subtract(5, 8);
  65.         logger.info("Operation result：{}",subtract);
  66.         // expected:期望值,  actual:运算的实际值
  67.         assertEquals(-3,subtract);
  68.     }
  69.     @AfterEach
  70.     void afterEach() {
  71.         mySUT.destroyId();
  72.     }
  73. }

运行测试类，对应运行结果：

  1. 2022-02-09 14:11:01 [main] INFO  top.testeru.MySUT.<init>(47) -- Open Calculator 
  2. 2022-02-09 14:11:01 [main] INFO  top.testeru.MySUT.initId(53) -- Generate ID：c48f445b-b9ce-4a1a-a16c-b9bc2aad19c2 
  3. 2022-02-09 14:11:01 [main] INFO  t.testeru.basic.BasicAnnotation2Test.subtractTest1(72) -- Begin Subtract Test
  4. 2022-02-09 14:11:01 [main] INFO  t.testeru.basic.BasicAnnotation2Test.subtractTest1(75) -- Operation result：-3
  5. 2022-02-09 14:11:01 [main] INFO  top.testeru.MySUT.destroyId(60) -- Release ID: c48f445b-b9ce-4a1a-a16c-b9bc2aad19c2 
  6. 2022-02-09 14:11:01 [main] INFO  top.testeru.MySUT.initId(53) -- Generate ID：48eb878b-60fa-43b6-b784-09ffc7f9f9b5 
  7. 2022-02-09 14:11:01 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest1(40) -- Begin Add Test
  8. 2022-02-09 14:11:01 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest1(44) -- Operation result：13
  9. 2022-02-09 14:11:01 [main] INFO  top.testeru.MySUT.destroyId(60) -- Release ID: 48eb878b-60fa-43b6-b784-09ffc7f9f9b5 
  10. 2022-02-09 14:11:01 [main] INFO  top.testeru.MySUT.initId(53) -- Generate ID：d4e7e3d8-7e38-45dd-a7e0-dfc5aa06e9aa 
  11. 2022-02-09 14:11:01 [main] INFO  top.testeru.MySUT.<init>(47) -- Open Calculator 
  12. 2022-02-09 14:11:01 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest2(54) -- Begin Add Test
  13. 2022-02-09 14:11:01 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest2(57) -- Addition result：1
  14. 2022-02-09 14:11:01 [main] INFO  top.testeru.MySUT.destroyId(60) -- Release ID: d4e7e3d8-7e38-45dd-a7e0-dfc5aa06e9aa 
  15. 2022-02-09 14:11:01 [main] INFO  top.testeru.MySUT.initId(53) -- Generate ID：720da8cb-07a1-4a36-9719-fe42af594b48 
  16. 2022-02-09 14:11:01 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest3(63) -- Begin Add Test
  17. 2022-02-09 14:11:01 [main] WARN  top.testeru.MySUT.sum(77) -- Please enter an integer in the range
  18. 2022-02-09 14:11:01 [main] INFO  top.testeru.MySUT.destroyId(60) -- Release ID: 720da8cb-07a1-4a36-9719-fe42af594b48
  • 结果显示不变

@AfterAll 

  2. @AfterAll
  3. void afterAll() {
  4.     mySUT.close();
  5. }

报错信息：

  1. org.junit.platform.commons.JUnitException: @AfterAll method 'void com.testeru.base.BasicAnnotation2Test.afterAll()' must be static unless the test class is annotated with @TestInstance(Lifecycle.PER_CLASS).
  • 对应@AfterAll需要static关键字修饰
  • 不可单独运行，需要运行测试类/方法
  • 在所有的方法后运行，包含AfterEach
  • @AfterAll注解的方法没有返回值，void
  1. package top.testeru.basic;
  3. import top.testeru.MySUT;
  4. import org.junit.jupiter.api.*;
  5. import org.slf4j.Logger;
  7. import static java.lang.invoke.MethodHandles.lookup;
  8. import static org.junit.jupiter.api.Assertions.*;
  9. import static org.slf4j.LoggerFactory.getLogger;
  11. /**
  12.  * @program: tutorials
  13.  * @author: testeru.top
  14.  * @description: 基本注解「方法注解」测试
  15.  * 加法测试用例「正常、边界值、超出边界值」
  16.  * 减法测试用例「正常」
  17.  * @Version 1.0
  18.  * @create: 2022/1/17 5:01 下午
  19.  */
  20. public class BasicAnnotation2Test {
  21.     static final Logger logger = getLogger(lookup().lookupClass());
  25.     static MySUT mySUT ;
  27.     @BeforeAll
  28.     static void beforeAll() {
  29.         mySUT = new MySUT("Calculator");
  30.     }
  33.     @BeforeEach
  34.     void beforeEach() {
  35.         mySUT.initId();
  36.     }
  38.     @Test
  39.     void addTest1(){
  40.         logger.info("Begin Add Test");
  41.         //加法运算
  42.         int sum = mySUT.sum(5, 8);
  43.         //所有的统称为运算结果
  44.         logger.info("Operation result：{}",sum);
  45.         // expected:期望值,  actual:运算的实际值
  46.         assertEquals(13,sum);
  47.     }
  51.     @Test
  52.     void addTest2(){
  53.         MySUT mySUT = new MySUT("Calculator");
  54.         logger.info("Begin Add Test");
  55.         //加法运算
  56.         int sum = mySUT.sum(99, -98);
  57.         logger.info("Addition result：{}",sum);
  58.         // expected:期望值,  actual:运算的实际值
  59.         assertEquals(1,sum);
  60.     }
  61.     @Test
  62.     void addTest3(){
  63.         logger.info("Begin Add Test");
  64.         //超过边界值的加法运算
  65.         Exception illegalArgumentException = assertThrows(IllegalArgumentException.class, () -> mySUT.sum(100, -98));
  66.         // expected:期望值,  actual:运算的实际值
  67.         assertTrue(illegalArgumentException.getMessage().contains("enter an integer in the range"));
  69.     }
  70.     @Test
  71.     void subtractTest1(){
  72.         logger.info("Begin Subtract Test");
  73.         //减法运算
  74.         int subtract = mySUT.subtract(5, 8);
  75.         logger.info("Operation result：{}",subtract);
  76.         // expected:期望值,  actual:运算的实际值
  77.         assertEquals(-3,subtract);
  78.     }
  79.     @AfterEach
  80.     void afterEach() {
  81.         mySUT.destroyId();
  82.     }
  84.     @AfterAll
  85.     static void afterAll() {
  86.         mySUT.close();
  87.     }
  88. }

运行测试类，对应运行结果：

  1. 2022-02-09 14:12:10 [main] INFO  top.testeru.MySUT.<init>(47) -- Open Calculator 
  2. 2022-02-09 14:12:10 [main] INFO  top.testeru.MySUT.initId(53) -- Generate ID：e0e5a64c-b66f-4f4b-b9d6-5e730f2c9173 
  3. 2022-02-09 14:12:10 [main] INFO  t.testeru.basic.BasicAnnotation2Test.subtractTest1(72) -- Begin Subtract Test
  4. 2022-02-09 14:12:10 [main] INFO  t.testeru.basic.BasicAnnotation2Test.subtractTest1(75) -- Operation result：-3
  5. 2022-02-09 14:12:10 [main] INFO  top.testeru.MySUT.destroyId(60) -- Release ID: e0e5a64c-b66f-4f4b-b9d6-5e730f2c9173 
  6. 2022-02-09 14:12:10 [main] INFO  top.testeru.MySUT.initId(53) -- Generate ID：4209abe8-4026-4119-a614-79f700abffa6 
  7. 2022-02-09 14:12:10 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest1(40) -- Begin Add Test
  8. 2022-02-09 14:12:10 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest1(44) -- Operation result：13
  9. 2022-02-09 14:12:10 [main] INFO  top.testeru.MySUT.destroyId(60) -- Release ID: 4209abe8-4026-4119-a614-79f700abffa6 
  10. 2022-02-09 14:12:10 [main] INFO  top.testeru.MySUT.initId(53) -- Generate ID：ab4a1da0-2b86-4f92-8b03-d93cfce00e19 
  11. 2022-02-09 14:12:10 [main] INFO  top.testeru.MySUT.<init>(47) -- Open Calculator 
  12. 2022-02-09 14:12:10 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest2(54) -- Begin Add Test
  13. 2022-02-09 14:12:10 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest2(57) -- Addition result：1
  14. 2022-02-09 14:12:10 [main] INFO  top.testeru.MySUT.destroyId(60) -- Release ID: ab4a1da0-2b86-4f92-8b03-d93cfce00e19 
  15. 2022-02-09 14:12:10 [main] INFO  top.testeru.MySUT.initId(53) -- Generate ID：bdd4b59d-83cb-4f58-8c37-3688ae228b48 
  16. 2022-02-09 14:12:10 [main] INFO  t.testeru.basic.BasicAnnotation2Test.addTest3(63) -- Begin Add Test
  17. 2022-02-09 14:12:10 [main] WARN  top.testeru.MySUT.sum(77) -- Please enter an integer in the range
  18. 2022-02-09 14:12:10 [main] INFO  top.testeru.MySUT.destroyId(60) -- Release ID: bdd4b59d-83cb-4f58-8c37-3688ae228b48 
  19. 2022-02-09 14:12:10 [main] INFO  top.testeru.MySUT.close(66) -- Close Calculator

项目编写规则

  • 对应前置操作放在基础BaseTest测试类中
  • 对应业务逻辑测试代码在业务测试类中

BaseTest

  1. package top.testeru.util;
  3. import top.testeru.MySUT;
  4. import org.junit.jupiter.api.AfterAll;
  5. import org.junit.jupiter.api.AfterEach;
  6. import org.junit.jupiter.api.BeforeAll;
  7. import org.junit.jupiter.api.BeforeEach;
  8. import org.slf4j.Logger;
  10. import static java.lang.invoke.MethodHandles.lookup;
  11. import static org.slf4j.LoggerFactory.getLogger;
  13. /**
  14.  * @program: tutorials
  15.  * @author: testeru.top
  16.  * @description: 基本测试类
  17.  * @Version 1.0
  18.  * @create: 2022/1/17 5:29 下午
  19.  */
  20. public class BaseTest {
  21.     public static final Logger logger = getLogger(lookup().lookupClass());
  23.     public void get(){
  24.         //获取当前类名
  25.         String name = new Exception().getStackTrace()[1].getClassName(); //获取调用者的类名
  27.         //获取调用者的方法名
  28.         String methodName = new Exception().getStackTrace()[1].getMethodName();
  29.         System.out.println(name+"："+methodName);
  30.     }
  32.     public static MySUT mySUT ;
  34.     @BeforeAll
  35.     static void beforeAll() {
  36.         mySUT = new MySUT("Calculator");
  37.     }
  40.     @BeforeEach
  41.     void beforeEach() {
  42.         mySUT.initId();
  43.     }
  46.     @AfterEach
  47.     void afterEach() {
  48.         mySUT.destroyId();
  49.     }
  51.     @AfterAll
  52.     static void afterAll() {
  53.         mySUT.close();
  54.     }
  55. }

业务逻辑代码

  1. package top.testeru.basic;
  4. import org.junit.jupiter.api.Test;
  5. import top.testeru.util.BaseTest;
  6. import top.testeru.MySUT;
  8. import static org.junit.jupiter.api.Assertions.*;
  10. /**
  11.  * @program: tutorials
  12.  * @author: testeru.top
  13.  * @description: 基本注解「方法注解」测试
  14.  * 加法测试用例「正常、边界值、超出边界值」
  15.  * 减法测试用例「2数相减、100连续减、」
  16.  * 字符串拼接
  17.  * 平均值
  18.  * @Version 1.0
  19.  * @create: 2022/1/17 5:01 下午
  20.  */
  21. public class BasicAnnotation3sTest extends BaseTest {
  23.     @Test
  24.     void addTest1(){
  25.         logger.info("Begin Add Test");
  26.         //加法运算
  27.         int sum = mySUT.sum(5, 8);
  28.         logger.info("Addition result：{}",sum);
  29.         // expected:期望值,  actual:运算的实际值
  30.         assertEquals(13,sum);
  31.     }
  32.     @Test
  33.     void addTest2(){
  34.         MySUT mySUT = new MySUT("Calculator");
  35.         logger.info("Begin Add Test");
  36.         //加法运算
  37.         int sum = mySUT.sum(99, -98);
  38.         logger.info("Addition result：{}",sum);
  39.         // expected:期望值,  actual:运算的实际值
  40.         assertEquals(1,sum);
  41.     }
  42.     @Test
  43.     void addTest3(){
  44.         logger.info("Begin Add Test");
  45.         //超过边界值的加法运算
  46.         Exception illegalArgumentException = assertThrows(IllegalArgumentException.class, () -> mySUT.sum(100, -98));
  47.         // expected:期望值,  actual:运算的实际值
  48.         assertTrue(illegalArgumentException.getMessage().contains("enter an integer in the range"));
  50.     }
  51.     @Test
  52.     void subtractTest1(){
  53.         logger.info("Begin Subtract Test");
  54.         //减法运算
  55.         int subtract = mySUT.subtract(5, 8);
  56.         logger.info("Operation result：{}",subtract);
  57.         // expected:期望值,  actual:运算的实际值
  58.         assertEquals(-3,subtract);
  59.     }
  61.     @Test
  62.     void subtractTest2(){
  63.         logger.info("Begin Continuous Subtract Test");
  64.         //100连续减
  65.         int subtract = mySUT.subtract(50,30,10,60);
  66.         logger.info("Operation result：{}",subtract);
  67.         // expected:期望值,  actual:运算的实际值
  68.         assertEquals(-50,subtract);
  69.     }
  70.     @Test
  71.     void csTest1(){
  72.         logger.info("Begin ConcatStr Test");
  73.         //字符串拼接
  74.         String concatStr = mySUT.concatStr("Hello","Junit5");
  75.         logger.info("Operation result：{}",concatStr);
  76.         // expected:期望值,  actual:运算的实际值
  77.         assertEquals("Hello Junit5",concatStr);
  78.     }
  80.     @Test
  81.     void avTest1(){
  82.         logger.info("Begin Average Test");
  84.         //平均值
  85.         double average = mySUT.average(55,44,86,72,64);
  86.         logger.info("Operation result：{}",average);
  87.         // expected:期望值,  actual:运算的实际值
  88.         assertEquals(64.2,average);
  89.     }
  91. }

运行顺序

  • 如果在业务逻辑测试类和Base测试类中都有@BeforeAll,@BeforeEach,@AfterEach,@AfterAll
  • 对应执行顺序？？？

一」基本的注解、断言 - 图3

结论：

  • B 继承 A
    • before开头的顺序都是A-B
    • after开头的顺序都是B-A