注解 说明
@DisplayName 自定义显示名称；类和方法上都可使用
@DisplayNameGeneration 定义显示名称规则；类上都使用
@Disable 禁用测试；类和方法上都可使用
@Tag 标记测试；类和方法上都可使用

@DisplayName

使用

@DisplayName注解不但可以放在测试方法上也可以放在测试类的上面。是一个类和方法都可以使用的注解。

eg : @DisplayName("This is a displayname annotation test")

对应括号内是string类型的字符串就是对应的显示内容，string类型内可以填写包含空格、特殊字符甚至表情符号😊。

eg : @DisplayName("😊计算器测试用例 ╯°□°）╯")

作用

作用就是自定义显示名称，自己想怎么显示就怎么显示。

一般情况下的作用就是在 IDE 和构建工具中的测试报告中自定义显示的类名和方法名，当然可以和allure报告结合，在allure报告中同样显示对应方法名和类名

总结

总结为以下几点：

  • 带注释的测试类或测试方法声明自定义显示名称
  • 通常用于 IDE 和构建工具中的测试报告
  • 可包含空格、特殊字符甚至表情符号😊
  • 结合Allure报告，可以显示对应方法名和类名 
  2. package top.testeru.common;  
  4. import top.testeru.util.BaseTest;  
  5. import org.junit.jupiter.api.DisplayName;  
  6. import org.junit.jupiter.api.Test;  
  8. import static org.junit.jupiter.api.Assertions.assertEquals;  
  10. /**  
  11.  * @program: tutorials  
  12.  * @author: testeru.top  
  13.  * @description: 常用注解测试：显示名称  
  14.  *    DisplayName:类+方法注解  
  15.  * @Version 1.0  
  16.  * @create: 2022/1/17 5:01 下午  
  17.  */  
  18. @DisplayName("😊Calculator Test╯°□°）╯")  
  19. public class CommonAnnotation1Test extends BaseTest {  
  21.     @DisplayName("加法")  
  22.     @Test  
  23.     void addTest1(){  
  24.         logger.info("Begin Add Test");  
  25.         //加法运算  
  26.         int sum = mySUT.sum(5, 8);  
  27.         logger.info("Operation result：{}",sum);  
  28.         // expected:期望值,  actual:运算的实际值  
  29.         assertEquals(13,sum);  
  30.     }  
  32.     @DisplayName("2数相减")  
  33.     @Test  
  34.     void subtractTest1(){  
  35.         logger.info("Begin Subtract Test");  
  36.         //减法运算  
  37.         int subtract = mySUT.subtract(5, 8);  
  38.         logger.info("Operation result：{}",subtract);  
  39.         // expected:期望值,  actual:运算的实际值  
  40.         assertEquals(-3,subtract);  
  41.     }  
  43.     @DisplayName("字符串拼接🐶")  
  44.     @Test  
  45.     void csTest1(){  
  46.         logger.info("Begin ConcatStr Test");  
  47.         //字符串拼接  
  48.         String concatStr = mySUT.concatStr("Hello","Junit5");  
  49.         logger.info("Operation result：{}",concatStr);  
  50.         // expected:期望值,  actual:运算的实际值  
  51.         assertEquals("Hello Junit5",concatStr);  
  52.     }  
  54.     @DisplayName("100连续减😱")  
  55.     @Test  
  56.     void subtractTest2(){  
  57.         logger.info("Begin Continuous Subtract Test");  
  58.         //100连续减  
  59.         int subtract = mySUT.subtract(50,30,10,60);  
  60.         logger.info("Operation result：{}",subtract);  
  61.         // expected:期望值,  actual:运算的实际值  
  62.         assertEquals(-50,subtract);  
  63.     }  
  65.     @DisplayName("平均数😐")  
  66.     @Test  
  67.     void avTest1(){  
  68.         logger.info("Begin Average Test");  
  69.         //平均值  
  70.         double average = mySUT.average(55,44,86,72,64);  
  71.         logger.info("Operation result：{}",average);  
  72.         // expected:期望值,  actual:运算的实际值  
  73.         assertEquals(64.2,average);  
  74.     }  
  76. }

二」常用注解 - 图1

@DisplayNameGeneration

使用

类上的注解，不能在方法上使用。

类上声明一次，对应的方法内也是用该类上声明的规则进行对应方法名称的显示。

作用

在类上添加该注解，并在注解内指明对应类，比如：DisplayNameGenerator.ReplaceUnderscores类，它会默认用空格替换名称中的任何下划线，无论是类名上的还是方法名上下划线都会被替换掉。

其实就是自己在类上声明@DisplayNameGeneration注解，并在注解内配置 当前类和方法的显示名称生成器规则

总结

  • 配置自定义显示名称生成器
  • DisplayNameGenerator.ReplaceUnderscores类，它用空格替换名称中的任何下划线 
  1. package top.testeru.common;  
  3. import org.junit.jupiter.api.DisplayNameGeneration;  
  4. import org.junit.jupiter.api.DisplayNameGenerator;  
  5. import org.junit.jupiter.api.Test;  
  6. import top.testeru.util.BaseTest;  
  8. import static org.junit.jupiter.api.Assertions.assertEquals;  
  10. /**  
  11.  * @program: tutorials  
  12.  * @author: testeru.top  
  13.  * @description: 常用注解测试：显示名称  
  14.  * DisplayNameGeneration  
  15.  * 空格替换名称中的任何下划线 ReplaceUnderscores  
  16.  * @Version 1.0  
  17.  * @create: 2022/1/17 5:01 下午  
  18.  */  
  19. @DisplayNameGeneration(DisplayNameGenerator.ReplaceUnderscores.class)  
  20. public class Common_Annotation2_Test extends BaseTest {  
  22.     @Test  
  23.     void add_test_1(){  
  24.         logger.info("Begin Add Test");  
  25.         //加法运算  
  26.         int sum = mySUT.sum(5, 8);  
  27.         logger.info("Operation result：{}",sum);  
  28.         // expected:期望值,  actual:运算的实际值  
  29.         assertEquals(13,sum);  
  30.     }  
  32.     @Test  
  33.     void subtract_test_1(){  
  34.         logger.info("Begin Subtract Test");  
  35.         //减法运算  
  36.         int subtract = mySUT.subtract(5, 8);  
  37.         logger.info("Operation result：{}",subtract);  
  38.         // expected:期望值,  actual:运算的实际值  
  39.         assertEquals(-3,subtract);  
  40.     }  
  42.     @Test  
  43.     void cs_test_1(){  
  44.         logger.info("Begin ConcatStr Test");  
  45.         //字符串拼接  
  46.         String concatStr = mySUT.concatStr("Hello","Junit5");  
  47.         logger.info("Operation result：{}",concatStr);  
  48.         // expected:期望值,  actual:运算的实际值  
  49.         assertEquals("Hello Junit5",concatStr);  
  50.     }  
  52.     @Test  
  53.     void subtract_test_2(){  
  54.         logger.info("Begin Continuous Subtract Test");  
  55.         //100连续减  
  56.         int subtract = mySUT.subtract(50,30,10,60);  
  57.         logger.info("Operation result：{}",subtract);  
  58.         // expected:期望值,  actual:运算的实际值  
  59.         assertEquals(-50,subtract);  
  60.     }  
  62.     @Test  
  63.     void av_test_1(){  
  64.         logger.info("Begin Average Test");  
  65.         //平均值  
  66.         double average = mySUT.average(55,44,86,72,64);  
  67.         logger.info("Operation result：{}",average);  
  68.         // expected:期望值,  actual:运算的实际值  
  69.         assertEquals(64.2,average);  
  70.     }  
  72. }

自定义显示名规则

步骤

编写静态内部类

继承Standard

重写方法
  • generateDisplayNameForClass :声明对应的类名 显示的规则
  • generateDisplayNameForMethod: 声明对应的方法名显示的规则 
  2. static class ReplaceCamelCase extends DisplayNameGenerator.Standard {
  3.         @Override
  4.         public String generateDisplayNameForClass(Class<?> testClass) {
  5.             return replaceCamelCase(super.generateDisplayNameForClass(testClass))+ "...";
  6.         }
  8.         @Override
  9.         public String generateDisplayNameForNestedClass(Class<?> nestedClass) {
  10.             return replaceCamelCase(super.generateDisplayNameForNestedClass(nestedClass));
  11.         }
  13.         @Override
  14.         public String generateDisplayNameForMethod(Class<?> testClass, Method testMethod) {
  15.             //+ DisplayNameGenerator.parameterTypesAsString(testMethod) 方法的括号
  16.             return this.replaceCamelCase(testClass.getSimpleName()+ "；方法名：" + testMethod.getName()+ ".");
  17.         }
  19.         String replaceCamelCase(String camelCase) {
  20.             StringBuilder result = new StringBuilder();
  21.             result.append(camelCase.charAt(0));
  22.             for (int i=1; i<camelCase.length(); i++) {
  23.                 if (Character.isUpperCase(camelCase.charAt(i))) {
  24.                     result.append(' ');
  25.                     result.append(Character.toLowerCase(camelCase.charAt(i)));
  26.                 } else {
  27.                     result.append(camelCase.charAt(i));
  28.                 }
  29.             }
  30.             return result.toString().replace("test","Test");
  31.         }
  32.     }

注意⚠️

方法/类上有@DisplayName，并且有自定义的显示规则优先级排序「优先级自上而下」：{1 > 2}

  1. 方法/类上的@DisplayName
  2. 自定义的显示规则

就是如果 方法/类上有@DisplayName则直接显示，如果没有则按自定义的显示规则进行显示

完整代码

  1. package com.testeru.base;
  3. import org.junit.jupiter.api.DisplayName;
  4. import org.junit.jupiter.api.DisplayNameGeneration;
  5. import org.junit.jupiter.api.DisplayNameGenerator;
  6. import org.junit.jupiter.api.Test;
  8. import java.lang.reflect.Method;
  10. import static org.junit.jupiter.api.Assertions.assertEquals;
  12. /**
  13.  * @program: tutorials
  14.  * @author: testeru.top
  15.  * @description: 自定义显示名称
  16.  * @Version 1.0
  17.  * @create: 2022/1/17 5:01 下午
  18.  */
  19. @DisplayNameGeneration(CommonAnnotation3Test.ReplaceCamelCase.class)
  20. public class CommonAnnotation3Test extends BaseTest{
  22.     @DisplayName("加法")  
  23.     @Test  
  24.     void addTest1(){  
  25.         logger.info("Begin Add Test");  
  26.         //加法运算  
  27.         int sum = mySUT.sum(5, 8);  
  28.         logger.info("Operation result：{}",sum);  
  29.         // expected:期望值,  actual:运算的实际值  
  30.         assertEquals(13,sum);  
  31.     }  
  33.     @Test  
  34.     void subtractTest1(){  
  35.         logger.info("Begin Subtract Test");  
  36.         //减法运算  
  37.          int subtract = mySUT.subtract(5, 8);  
  38.         logger.info("Operation result：{}",subtract);  
  39.         // expected:期望值,  actual:运算的实际值  
  40.          assertEquals(-3,subtract);  
  41.     }  
  43.     @Test  
  44.     void csTest1(){  
  45.         logger.info("Begin ConcatStr Test");  
  46.         //字符串拼接  
  47.          String concatStr = mySUT.concatStr("Hello","Junit5");  
  48.         logger.info("Operation result：{}",concatStr);  
  49.         // expected:期望值,  actual:运算的实际值  
  50.          assertEquals("Hello Junit5",concatStr);  
  51.     }  
  53.     @Test  
  54.     void subtractTest2(){  
  55.         logger.info("Begin Continuous Subtract Test");  
  56.         //100连续减  
  57.          int subtract = mySUT.subtract(50,30,10,60);  
  58.         logger.info("Operation result：{}",subtract);  
  59.         // expected:期望值,  actual:运算的实际值  
  60.          assertEquals(-50,subtract);  
  61.     }  
  63.     @Test  
  64.     void avTest1(){  
  65.         logger.info("Begin Average Test");  
  66.         //平均值  
  67.          double average = mySUT.average(55,44,86,72,64);  
  68.         logger.info("Operation result：{}",average);  
  69.         // expected:期望值,  actual:运算的实际值  
  70.          assertEquals(64.2,average);  
  71.     }
  73.     //标准显示名称生成行为 Standard默认配置
  74.     static class ReplaceCamelCase extends DisplayNameGenerator.Standard {
  75.         @Override
  76.         public String generateDisplayNameForClass(Class<?> testClass) {
  77.             return replaceCamelCase(super.generateDisplayNameForClass(testClass))+ "...";
  78.         }
  80.         @Override
  81.         public String generateDisplayNameForNestedClass(Class<?> nestedClass) {
  82.             return replaceCamelCase(super.generateDisplayNameForNestedClass(nestedClass));
  83.         }
  85.         @Override
  86.         public String generateDisplayNameForMethod(Class<?> testClass, Method testMethod) {
  87.             //+ DisplayNameGenerator.parameterTypesAsString(testMethod) 方法的括号
  88.             return this.replaceCamelCase(testClass.getSimpleName()+ "；方法名：" + testMethod.getName()+ ".");
  89.         }
  91.         String replaceCamelCase(String camelCase) {
  92.             StringBuilder result = new StringBuilder();
  93.             result.append(camelCase.charAt(0));
  94.             for (int i=1; i<camelCase.length(); i++) {
  95.                 if (Character.isUpperCase(camelCase.charAt(i))) {
  96.                     result.append(' ');
  97.                     result.append(Character.toLowerCase(camelCase.charAt(i)));
  98.                 } else {
  99.                     result.append(camelCase.charAt(i));
  100.                 }
  101.             }
  102.             return result.toString().replace("test","Test");
  103.         }
  104.     }
  105. }

二」常用注解 - 图2

@Disable

使用

@Disable注解不但可以放在测试方法上也可以放在测试类的上面。是一个类和方法都可以使用的注解。

eg : @Disabled("平均值有bug")

对应括号内是string类型的字符串就是对应方法/类被禁用的原因。也可以不写括号及括号内的string，默认就是返回值 包名.类名.方法 is @Disabled

eg :void top.testeru.common.CommonAnnotation4Test.csTest1() is @Disabled

作用

该注解在方法上声明对应的方法则不被执行，但是方法的类还是依然会被实例化。

如果注解在类上声明则该类下所有测试方法都不被执行，对应类也不会实例化。

总结

  • 表示带注释的测试类或测试方法当前已禁用，不应执行
  • 可以添加()并声明原因
  • 在类级别应用时，该类中的所有测试方法会自动禁用
  • 在方法级别应用时，@Disable不会阻止测试类被实例化
  • 会阻止执行测试方法和方法级别的生命周期回调 
  1. package top.testeru.common;
  3. import org.junit.jupiter.api.*;
  4. import top.testeru.util.BaseTest;
  6. import java.lang.reflect.Method;
  8. import static org.junit.jupiter.api.Assertions.assertEquals;
  10. /**
  11.  * @program: tutorials
  12.  * @author: testeru.top
  13.  * @description: 常用注解测试：
  14.  * 禁用测试方法：@Disable
  15.  *    括号内有描述显示描述信息
  16.  *    不带括号，显示默认信息：{返回值 包名.类名.方法名 is @Disabled}
  17.  * 显示名称
  18.  *    自定义显示名称
  19.  * @Version 1.0
  20.  * @create: 2022/1/17 5:01 下午
  21.  */
  22. @DisplayNameGeneration(CommonAnnotation4Test.ReplaceCamelCase.class)
  23. public class CommonAnnotation4Test extends BaseTest {
  25.     @DisplayName("加法")
  26.     @Test
  27.     void addTest1(){
  28.         logger.info("Begin Add Test");
  29.         //加法运算
  30.         int sum = mySUT.sum(5, 8);
  31.         logger.info("Operation result：{}",sum);
  32.         // expected:期望值,  actual:运算的实际值
  33.         assertEquals(13,sum);
  34.     }
  36.     @Test
  37.     void subtractTest1(){
  38.         logger.info("Begin Subtract Test");
  39.         //减法运算
  40.         int subtract = mySUT.subtract(5, 8);
  41.         logger.info("Operation result：{}",subtract);
  42.         // expected:期望值,  actual:运算的实际值
  43.         assertEquals(-3,subtract);
  44.     }
  46.     @DisplayName("字符串拼接🐶")
  47.     @Test
  48.     @Disabled
  49.     void csTest1(){
  50.         logger.info("Begin ConcatStr Test");
  51.         //字符串拼接
  52.         String concatStr = mySUT.concatStr("Hello","Junit5");
  53.         logger.info("Operation result：{}",concatStr);
  54.         // expected:期望值,  actual:运算的实际值
  55.         assertEquals("Hello Junit5",concatStr);
  56.     }
  58.     @Test
  59.     void subtractTest2(){
  60.         logger.info("Begin Continuous Subtract Test");
  61.         //100连续减
  62.         int subtract = mySUT.subtract(50,30,10,60);
  63.         logger.info("Operation result：{}",subtract);
  64.         // expected:期望值,  actual:运算的实际值
  65.         assertEquals(-50,subtract);
  66.     }
  68.     @Test
  69.     @Disabled("平均值有bug")
  70.     void avTest1(){
  71.         logger.info("Begin Average Test");
  72.         //平均值
  73.         double average = mySUT.average(55,44,86,72,64);
  74.         logger.info("Operation result：{}",average);
  75.         // expected:期望值,  actual:运算的实际值
  76.         assertEquals(64.2,average);
  77.     }
  80.     //标准显示名称生成行为 Standard默认配置
  81.     static class ReplaceCamelCase extends DisplayNameGenerator.Standard {
  82.         @Override
  83.         public String generateDisplayNameForClass(Class<?> testClass) {
  84.             return replaceCamelCase(super.generateDisplayNameForClass(testClass))+ "...";
  85.         }
  87.         @Override
  88.         public String generateDisplayNameForNestedClass(Class<?> nestedClass) {
  89.             return replaceCamelCase(super.generateDisplayNameForNestedClass(nestedClass));
  90.         }
  92.         @Override
  93.         public String generateDisplayNameForMethod(Class<?> testClass, Method testMethod) {
  94.             //+ DisplayNameGenerator.parameterTypesAsString(testMethod) 方法的括号
  95.             return this.replaceCamelCase(testClass.getSimpleName()+ "；方法名：" + testMethod.getName()+ ".");
  96.         }
  98.         String replaceCamelCase(String camelCase) {
  99.             StringBuilder result = new StringBuilder();
  100.             result.append(camelCase.charAt(0));
  101.             for (int i=1; i<camelCase.length(); i++) {
  102.                 if (Character.isUpperCase(camelCase.charAt(i))) {
  103.                     result.append(' ');
  104.                     result.append(Character.toLowerCase(camelCase.charAt(i)));
  105.                 } else {
  106.                     result.append(camelCase.charAt(i));
  107.                 }
  108.             }
  109.             return result.toString().replace("test","Test");
  110.         }
  111.     }
  113. }

二」常用注解 - 图3

注意⚠️

  • 对应不执行的测试方法的@BeforeEach和@AfterEach都没有执行
  • 如果有描述，显示不执行的描述，如果没有描述内容，显示对应方法名不被执行

@Tag

使用

@Tag注解不但可以放在测试方法上也可以放在测试类的上面。是一个类和方法都可以使用的注解。可以在一个类/方法上有多个，也可以只有一个。

eg :

  • 只有一个：@Tag("decimal")
  • 有多个：
  1. @Tags({  
  2.         @Tag("decimal"),  
  3.         @Tag("dev")  
  4. })

命名规范

对应Tag标签的标识名称的命名规范，首先不能是空的字符串，空字符串对应的没有意义，同时标签名称不能有对应的空格及ISO控制字符。

一般情况下，对应的名称都为英文或者是中文来做区分即可。

总结为以下几点：

  • 不为空
  • 标签不得包含空格
  • 标签不得包含 ISO 控制字符。
  • 标签不得包含以下任何保留字符
  1. ,
  2. (
  3. )
  4. &
  5. |
  6. !

作用

在运行suite套件的时候可以指定对应tag标签来运行特定的类或者方法，只要是对应类或方法上有该标签就会运行。

也可以在pom文件中进行对应group的配置，这样对应的可以只运行特定的方法和类。

总结以上，@Tag注解就是为了特定运行某些方法和类。

总结

  • 标记测试
  • 测试类或测试方法声明

应用

用例分组
  • 环境分组： 测试环境、预发布环境
  • 阶段分组： 冒烟用例
  • 版本分组： V1.1、V1.2

自定义组成的注释命名

  • 接口名随便定义，不一定非要Test结尾

自定义方法上元注释

步骤
  • 自定义元注解写在测试方法上
  • 生成对应接口文件
  • 在接口文件上添加对应注解即可

实现效果
  • @IntTagTest 替换 @Test+@Tag("integer")
  • 示例代码 
  1.     @DisplayName("加法")
  2. //    @Test
  3. //    @Tag("integer")
  4. @IntTagTest
  5.     void addTest1(){
  6.             logger.info("Begin Add Test");
  7.             //加法运算
  8.             int sum = mySUT.sum(5, 8);
  9.             logger.info("Operation result：{}",sum);
  10.             // expected:期望值,  actual:运算的实际值
  11.             assertEquals(13,sum);
  12.             }

实现代码
  1. package top.testeru.util;
  3. import org.junit.jupiter.api.Tag;
  4. import org.junit.jupiter.api.Test;
  6. import java.lang.annotation.ElementType;
  7. import java.lang.annotation.Retention;
  8. import java.lang.annotation.RetentionPolicy;
  9. import java.lang.annotation.Target;
  11. /**
  12.  * @Package: top.testeru.util
  13.  * @author: testeru.top
  14.  * @Description:
  15.  * @date: 2022年02月09日 3:03 PM
  16.  */
  18. @Target(ElementType.METHOD)
  19. @Retention(RetentionPolicy.RUNTIME)
  20. @Tag("integer")
  21. @Test
  22. public @interface IntTagTest {
  23. }

说明
  1. ElementType.METHOD代表该注解只是在方法上才可以使用
  2. RetentionPolicy.RUNTIME注释将由编译器记录在类文件中，并在运行时由 VM 保留，因此可以反射性地读取它们

自定义类上元注释

步骤
  • 自定义元注解写在测试类上
  • 生成对应接口文件
  • 在接口文件上添加对应注解即可

实现效果
  • @MyClassTag 替换类上的注解 @Tag("mytag")
  • 示例代码 
  1. @MyClassTag
  2. public class CommonAnnotation6Test extends BaseTest {
  3. ...
  4. }

实现代码
  1. package top.testeru.util;
  3. import org.junit.jupiter.api.Tag;
  5. import java.lang.annotation.*;
  7. /**
  8.  * @Package: top.testeru.util
  9.  * @author: testeru.top
  10.  * @Description:
  11.  * @date: 2022年02月09日 3:09 PM
  12.  */
  13. @Target({ ElementType.TYPE, ElementType.METHOD })
  14. @Retention(RetentionPolicy.RUNTIME)
  15. @Tag("mytag")
  16. @Documented
  17. public @interface MyClassTag {
  18. }

@RepeatedTest

  • 想要重复多次的任何测试方法
  • 只能添加在测试方法上，和Test使用方法一致
  • 方法不能是私有的或静态的，并且返回值必须是void
  • ()内为执行的次数
  • 方法上有@RepeatedTest则不需要@Test
    • 不然真正执行的次数为RepeatedTest的参数值 + 1
  1. package com.testeru.classes;
  3. import org.junit.jupiter.api.*;
  5. /**
  6.  * @program: tutorials
  7.  * @author: testeru.top
  8.  * @description:
  9.  * @Version 1.0
  10.  * @create: 2022/1/7 4:46 下午
  11.  */
  12. @DisplayName("junit5 test")
  13. public class FourDemoTest extends BaseDemoTest{
  15.     @BeforeAll
  16.     static void beforeAll1(){
  17.         System.out.println("---进入到首页---");
  18.     }
  19.     @BeforeEach
  20.     void beforeEach1(){
  21.         System.out.println("---搜索商品---");
  22.     }
  23.     @DisplayName("first test")
  24.     @Test
  25.     void test(){
  26.         System.out.println("---点击查看第 1 个商品详情---");
  27.     }
  28.     @DisplayName("second test")
  29.     @Disabled("先不执行")
  30.     @Test
  31.     void test2(){
  32.         System.out.println("---点击查看第 2 个商品详情---");
  33.     }
  34.     @DisplayName("third test")
  35.     @Disabled
  36.     @Test
  37.     void test3(){
  38.         System.out.println("---点击查看第 2 个商品详情---");
  39.     }
  41.     @DisplayName("five test")
  42.     @RepeatedTest(3)
  43.     void test5(){
  44.         System.out.println("---点击查看第 6 个商品详情---");
  45.     }
  46.     @AfterEach
  47.     void afterEach1(){
  48.         System.out.println("---添加购物车---");
  49.     }
  50.     @AfterAll
  51.     static void afterAll1(){
  52.         System.out.println("---进入购物车列表，生成订单，进行订单付款---");
  53.     }
  54. }

二」常用注解 - 图4

  • 相当于重复写了3个相同的方法
  • 对应beforeeach和aftereach都会随着重复次数来执行

自定义显示名称

  • @RepeatedTest(value = 3,name = "Custom name {currentRepetition}/{totalRepetitions}")
    • value
      • 重复执行多少次
    • name
      • 对应每次执行的自定义名称
      • currentRepetition：当前重复次数
      • totalRepetitions：重复的总数
  1. package com.testeru.classes;
  3. import org.junit.jupiter.api.*;
  5. /**
  6.  * @program: tutorials
  7.  * @author: testeru.top
  8.  * @description:
  9.  * @Version 1.0
  10.  * @create: 2022/1/7 4:46 下午
  11.  */
  12. @DisplayName("junit5 test")
  13. public class FourDemoTest extends BaseDemoTest{
  15.     @BeforeAll
  16.     static void beforeAll1(){
  17.         System.out.println("---进入到首页---");
  18.     }
  19.     @BeforeEach
  20.     void beforeEach1(){
  21.         System.out.println("---搜索商品---");
  22.     }
  23.     @DisplayName("first test")
  24.     @Test
  25.     void test(){
  26.         System.out.println("---点击查看第 1 个商品详情---");
  27.     }
  28.     @DisplayName("second test")
  29.     @Disabled("先不执行")
  30.     @Test
  31.     void test2(){
  32.         System.out.println("---点击查看第 2 个商品详情---");
  33.     }
  34.     @DisplayName("third test")
  35.     @Disabled
  36.     @Test
  37.     void test3(){
  38.         System.out.println("---点击查看第 2 个商品详情---");
  39.     }
  41.     @DisplayName("five test")
  42.     @RepeatedTest(value = 3,name = "Custom name {currentRepetition}/{totalRepetitions}")
  43.     void test5(){
  44.         System.out.println("---点击查看第 6 个商品详情---");
  45.     }
  46.     @AfterEach
  47.     void afterEach1(){
  48.         System.out.println("---添加购物车---");
  49.     }
  50.     @AfterAll
  51.     static void afterAll1(){
  52.         System.out.println("---进入购物车列表，生成订单，进行订单付款---");
  53.     }
  54. }

二」常用注解 - 图5

方法内调用

  • 方法内想要知道调用当前是第几次重复和总共重复的次数
  1. @RepeatedTest(value = 3,name = "Custom name {currentRepetition}/{totalRepetitions}")
  2. void test4(RepetitionInfo repetitionInfo) {
  3.     int currentRepetition = repetitionInfo.getCurrentRepetition();
  4.     System.out.println("第" + currentRepetition +"次搜索 查看第 " + currentRepetition + "个商品详情");
  5. }

二」常用注解 - 图6

  • 测试方法不是@RepeatedTest，则不能将RepetitionInfo 注入到 @BeforeEach 或 @AfterEach 方法中
  1. package com.testeru.classes;
  3. import org.junit.jupiter.api.*;
  5. /**
  6.  * @program: tutorials
  7.  * @author: testeru.top
  8.  * @description:
  9.  * @Version 1.0
  10.  * @create: 2022/1/7 4:46 下午
  11.  */
  12. @DisplayName("junit5 test")
  13. public class FiveDemoTest{
  15.     @BeforeEach
  16.     void beforeEach1(RepetitionInfo repetitionInfo){
  17.         int currentRepetition = repetitionInfo.getCurrentRepetition();
  19.         System.out.println("---搜索商品---" + currentRepetition);
  20.     }
  22.     @AfterEach
  23.     void afterEach1(RepetitionInfo repetitionInfo){
  24.         int currentRepetition = repetitionInfo.getCurrentRepetition();
  26.         System.out.println("---添加购物车---"+ currentRepetition);
  27.     }
  29.     @DisplayName("four test")
  30.     @RepeatedTest(value = 3,name = "重复搜索次数 {currentRepetition}/{totalRepetitions}")
  31.     void test4(RepetitionInfo repetitionInfo) {
  32.         int currentRepetition = repetitionInfo.getCurrentRepetition();
  33.         System.out.println("第" + currentRepetition +"次搜索 查看第 " + currentRepetition + "个商品详情");
  34.     }
  36.     @DisplayName("third test")
  37.     @Test
  38.     void test3(){
  39.         System.out.println("---点击查看第 2 个商品详情---");
  40.     }
  43.     @DisplayName("first test")
  44.     @RepeatedTest(2)
  45.     void test1(){
  46.         System.out.println("---点击查看第 1 个商品详情---");
  47.     }
  48. }

报错：

  1. org.junit.jupiter.api.extension.ParameterResolutionException: No ParameterResolver registered for parameter [org.junit.jupiter.api.RepetitionInfo arg0] in method [void com.testeru.classes.FiveDemoTest.beforeEach1(org.junit.jupiter.api.RepetitionInfo)].

二」常用注解 - 图7