langzitianya
langzitianya

JUnit5学习

以下学习内容基于JUnit5英文文档和中文文档

目录

JUnit 5是什么

注解说明

元注解和组合注解

标准测试类

显示名称(DisplayName)

断言(Assertions)

假设(Assumptions)

条件测试执行(Conditional Test Execution)

标签和过滤(Tagging and Filtering)

测试执行顺序

  测试方法执行顺序

  测试类执行顺序

测试实例生命周期(Test Instance Lifecycle)  

嵌套测试(Nested Tests)

对构造函数和方法的依赖注入(Dependency Injection for Constructors and Methods)

测试接口和默认方法(Test Interfaces and Default Methods)

重复测试(Repeated Tests)

参数化测试(Parameterized Tests)

  @ValueSource

  @NullSource

  @EmptySource

  @NullAndEmptySource

  可以组合使用@NullSource, @EmptySource和@ValueSource

  @EnumSource

  @MethodSource

  @CsvSource

  @CsvFileSource

  @ArgumentsSource

  参数转换(Argument Conversion)

  参数聚合(Argument Conversion)

  自定义显示的名字(Customizing Display Names)

  生命周期和互操作性(Lifecycle and Interoperability)

测试模板(Test Templates)  

动态测试(Dynamic Tests)

超时(Timeouts)

JUnit 5是什么

  JUnit 5 = JUnit Platform(基础平台) + JUnit Jupiter(核心程序) + JUnit Vintage(老版本的支持)
  JUnit Platform
    在JVM上启动测试框架(launching testing frameworks)的基础。
    它还定义了用于开发平台上运行的测试框架的测试引擎(TestEngine)API。
    此外，该平台还提供了一个控制台启动器(Console Launcher)，可以从命令行启动平台，并为 Gradle 和 Maven 构建插件，以及一个基于JUnit 4的运行器(JUnit 4 based Runner)，用于在平台上运行任何 TestEngine 。
  JUnit Jupiter
    在JUnit 5中编写测试和扩展的新编程模型( programming model )和扩展模型( extension model )的组合。
    另外，Jupiter子项目还提供了一个TestEngine，用于在平台上运行基于Jupiter的测试。
  JUnit Vintage
    提供了一个在平台上运行JUnit 3和JUnit 4的 TestEngine 。

注解说明

  @Test
    表示方法是一种测试方法。
    与JUnit 4的 @Test 注解不同，这个注解没有声明任何属性，因为JUnit Jupiter的测试扩展是基于它们自己的专用注解进行操作的。
    这些方法可以被继承，除非它们被重写。
  @ParameterizedTest
    表示方法是 parameterized test(参数化测试)。
    这些方法可以被继承，除非它们被重写。
  @RepeatedTest
    表示方法是 repeated test(重复测试)的测试模板。
    这些方法可以被继承，除非它们被重写。
  @TestFactory
    表示方法是用于dynamic tests(动态测试)的测试工厂。
    这些方法可以被继承，除非它们被重写。
  @TestTemplate
    表示方法是用来根据注册providers(提供者)返回的调用上下文多次调用的template for test cases(测试用例的模板)。
    这些方法可以被继承，除非它们被重写。
  @TestClassOrder
    用于配置带有此注解的测试类中@Nested测试类的执行顺序。
    这些注解可以被继承。
  @TestMethodOrder 类似JUnit4的@FixMethodOrder
    用于配置带有此注解的测试类中测试方法的执行顺序。
    这些注解可以被继承。
  @TestInstance
    用于为带注解的测试类配置test instance lifecycle(测试实例生命周期)。
    这些注解可以被继承。
  @DisplayName
    声明测试类或测试方法的自定义显示名称。
    这样的注解不能被继承。
  @DisplayNameGeneration
    为测试类配置显示名称生成器。
    这些注解可以被继承。
  @BeforeEach 类似JUnit4的@Before
    表示在当前类中每个 @Test, @RepeatedTest, @ParameterizedTest或 @TestFactory 方法执行前都要执行这个方法;
    这些方法可以被继承，除非它们被重写。
  @AfterEach 类似JUnit4的@After
    表示在当前类中每个@Test, @RepeatedTest, @ParameterizedTest或 @TestFactory方法执行后都要执行这个方法;
    这些方法可以被继承，除非它们被重写。
  @BeforeAll 类似JUnit4的@BeforeClass
    表示在当前类中只运行一次，在所有@Test, @RepeatedTest, @ParameterizedTest或 @TestFactory方法执行前运行;
    这些方法可以被继承的(除非它们是隐藏的或覆盖的)，并且必须是 static 的(除非使用“per-class”test instance lifecycle (测试实例生命周期))。
  @AfterAll 类似JUnit4的@AfterClass
    表示在当前类中只运行一次，在所有@Test, @RepeatedTest, @ParameterizedTest或 @TestFactory方法执行后运行;
    这些方法可以被继承(除非它们是隐藏的或覆盖的)，并且必须是静态的(除非使用“per-class”test instance lifecycle (测试实例生命周期))。
  @Nested
    表示带注解的类是内嵌的非静态测试类。
    @BeforeAll 和 @AfterAll方法不能直接在 @Nested 测试类中使用，(除非使用“per-class”test instance lifecycle (测试实例生命周期))。
    这样的注解不能被继承。
  @Tag
    用于在类或方法级别为过滤测试声明tags;类似于TestNG中的测试组或JUnit 4中的分类。
    此注解只能用于类级别不能用在方法级别。
  @Disabled 类似JUnit4的@Ignore
    用于禁用测试类或测试方法;
    这样的注解不能被继承。
  @Timeout
    用于在测试、测试工厂、测试模板或生命周期方法的执行超过给定持续时间时使其失败。
    这些注解可以被继承。
  @ExtendWith
    以声明的方式注册自定义 extensions (扩展)。
    这些注解不能被继承。
  @RegisterExtension
    在测试类中注释字段来以编程方式注册扩展。
    当扩展通过@RegisterExtension注册时，可以通过编程方式配置它——例如，为了将参数传递给扩展的构造函数、静态工厂方法或构建器API。
    @RegisterExtension 字段不能是 private 或 null(在评估时)，但是可以是静态的，也可以是非静态的。
    这些字段可以被继承，除非它们被隐藏。
  @TempDir
    用于在生命周期方法或测试方法中通过字段注入或参数注入提供临时目录;
    位于org.unit.jupiter.api.io包中。

元注解和组合注解

  JUnit Jupiter注解可以用作元注解。这意味着您可以定义自己的组合注解，它将自动继承其元注解的语义。
  比如下面定义了新注解@Fast，可以替代@Tag("fast")

    @Target({ ElementType.TYPE, ElementType.METHOD })
    @Retention(RetentionPolicy.RUNTIME)
    @Tag("fast")
    public @interface Fast {
    }

标准测试类

  import static org.junit.jupiter.api.Assertions.fail;

  import org.junit.jupiter.api.AfterAll;
  import org.junit.jupiter.api.AfterEach;
  import org.junit.jupiter.api.BeforeAll;
  import org.junit.jupiter.api.BeforeEach;
  import org.junit.jupiter.api.Disabled;
  import org.junit.jupiter.api.Test;

  class StandardTests {

      @BeforeAll
      static void initAll() {
      }

      @BeforeEach
      void init() {
      }

      @Test
      void succeedingTest() {
      }

      @Test
      void failingTest() {
          fail("a failing test");
      }

      @Test
      @Disabled("for demonstration purposes")
      void skippedTest() {
          // not executed
      }

      @AfterEach
      void tearDown() {
      }

      @AfterAll
      static void tearDownAll() {
      }

  }

显示名称(DisplayName)

  可以在测试类或者测试方法上使用@DisplayName("A special test case")定义显示名称

  可以在测试类上使用@DisplayNameGeneration设置显示名称生成器
    自带可选的生成器：

Standard

默认生成器

可以设置配置项目改变默认生成器

  junit.jupiter.displayname.generator.default = org.junit.jupiter.api.DisplayNameGenerator$ReplaceUnderscores
Simple 去除不带参数的方法后面的"()"
ReplaceUnderscores 使用空格替换下划线
IndicativeSentences 通过连接测试方法和封闭类的名称来生成完整名称 
    // 名称：DisplayNameGeneratorDemo
    class DisplayNameGeneratorDemo {

        // 名称：A year is not supported
        @Nested
        @DisplayNameGeneration(DisplayNameGenerator.ReplaceUnderscores.class)
        class A_year_is_not_supported {
            // 名称：if it is zero()
            @Test
            void if_it_is_zero() {
            }
            // 名称：A negative value for year is not supported by the leap year computation.
            //       For example, year -1 is not supported.
            //       For example, year -4 is not supported.
            @DisplayName("A negative value for year is not supported by the leap year computation.")
            @ParameterizedTest(name = "For example, year {0} is not supported.")
            @ValueSource(ints = { -1, -4 })
            void if_it_is_negative(int year) {
            }
        }

        // 名称：A year is a leap year
        @Nested
        @IndicativeSentencesGeneration(separator = " -> ", generator = DisplayNameGenerator.ReplaceUnderscores.class)
        class A_year_is_a_leap_year {
            // 名称：A year is a leap year -> if it is divisible by 4 but not by 100.
            @Test
            void if_it_is_divisible_by_4_but_not_by_100() {
            }
            // 名称：A year is a leap year -> if it is one of the following years.
            //       Year 2016 is a leap year.
            //       Year 2020 is a leap year.
            //       Year 2048 is a leap year.
            @ParameterizedTest(name = "Year {0} is a leap year.")
            @ValueSource(ints = { 2016, 2020, 2048 })
            void if_it_is_one_of_the_following_years(int year) {
            }
        }
    }

断言(Assertions)

  JUnit Jupiter 附带了许多JUnit 4所拥有的断言方法，并添加了一些可以很好地使用Java 8 lambdas的方法。
  所有的JUnit Jupiter断言都是org.junit.jupiter.api.Assertions (断言类)中的静态方法。

  // 断言 expected == actual
  assertEquals(type expected, type actual)
  assertEquals(type expected, type actual, String message)
  assertEquals(type expected, type actual, Supplier messageSupplier)
  // 断言 delta > 0.0 && Math.abs(expected - actual) <= delta
  assertEquals(type expected, type actual, type delta)
  assertEquals(type expected, type actual, type delta, String message)
  assertEquals(type expected, type actual, type delta, Supplier messageSupplier)
  // 相反断言
  assertNotEquals,参数与assertEquals一样

  // 断言 expected和actual数组元素个数一致 && 内容全相等
  assertArrayEquals(type[] expected, type[] actual)
  assertArrayEquals(type[] expected, type[] actual, String message)
  assertArrayEquals(type[] expected, type[] actual, Supplier messageSupplier)
  // 断言 delta > 0.0 && expected和actual数组元素个数一致 && 每个元素符合Math.abs(expected[i] - actual[i]) <= delta
  assertArrayEquals(type[] expected, type[] actual, type delta)
  assertArrayEquals(type[] expected, type[] actual, type delta, String message)
  assertArrayEquals(type[] expected, type[] actual, type delta, Supplier messageSupplier)

  // 断言 expected和actual包含的元素一致，支持嵌套的Iterable
  assertIterableEquals(Iterable expected, Iterable actual)
  assertIterableEquals(Iterable expected, Iterable actual, String message)
  assertIterableEquals(Iterable expected, Iterable actual, Supplier messageSupplier)

  // 断言 expectedLines和actualLines都不为空 && 内容全相等
  assertLinesMatch(List expectedLines, List actualLines)
  assertLinesMatch(List expectedLines, List actualLines, String message)
  assertLinesMatch(List expectedLines, List actualLines, Supplier messageSupplier)
  assertLinesMatch(Stream expectedLines, Stream actualLines)
  assertLinesMatch(Stream expectedLines, Stream actualLines, String message)
  assertLinesMatch(Stream expectedLines, Stream actualLines, Supplier messageSupplier)

  // 断言 expected和actual指向同一个对象
  assertSame(Object expected, Object actual)
  assertSame(Object expected, Object actual, String message)
  assertSame(Object expected, Object actual, Supplier messageSupplier)
  // 相反断言
  assertNotSame,参数与assertSame一样

  // 断言 condition == true 或者 booleanSupplier返回true
  assertTrue(boolean condition)
  assertTrue(boolean condition, String message)
  assertTrue(boolean condition, Supplier messageSupplier)
  assertTrue(BooleanSupplier booleanSupplier)
  assertTrue(BooleanSupplier booleanSupplier, String message)
  assertTrue(BooleanSupplier booleanSupplier, Supplier messageSupplier)
  // 相反断言
  assertFalse,参数与assertTrue一样

  // 断言 actual == null
  assertNull(Object actual)
  assertNull(Object actual, String message)
  assertNull(Object actual, Supplier messageSupplier)
  // 相反断言
  assertNotNull,参数与assertNull一样

  // 断言 expectedType.isInstance(actualValue)，并返回类型转换后的对象
  T assertInstanceOf(Class expectedType, Object actualValue)
  T assertInstanceOf(Class expectedType, Object actualValue, String message)
  T assertInstanceOf(Class expectedType, Object actualValue, Supplier messageSupplier)

  // 断言 executable执行后抛出expectedType类型的异常
  assertThrows(Class expectedType, Executable executable)
  assertThrows(Class expectedType, Executable executable, String message)
  assertThrows(Class expectedType, Executable executable, Supplier messageSupplier)
  // 断言 executable执行后抛出expectedType精准类型的异常
  assertThrowsExactly(Class expectedType, Executable executable)
  assertThrowsExactly(Class expectedType, Executable executable, String message)
  assertThrowsExactly(Class expectedType, Executable executable, Supplier messageSupplier)
  // 断言 executable或supplier执行后不抛出任何异常
  assertDoesNotThrow(Executable executable)
  assertDoesNotThrow(Executable executable, String message)
  assertDoesNotThrow(Executable executable, Supplier messageSupplier)
  assertDoesNotThrow(ThrowingSupplier supplier)
  assertDoesNotThrow(ThrowingSupplier supplier, String message)
  assertDoesNotThrow(ThrowingSupplier supplier, Supplier messageSupplier)

  // 断言 executable或supplier在timeout之内执行完成，会在主线程等待执行完成
  assertTimeout(Duration timeout, Executable executable)
  assertTimeout(Duration timeout, Executable executable, String message)
  assertTimeout(Duration timeout, Executable executable, Supplier messageSupplier)
  T assertTimeout(Duration timeout, ThrowingSupplier supplier)
  T assertTimeout(Duration timeout, ThrowingSupplier supplier, String message)
  T assertTimeout(Duration timeout, ThrowingSupplier supplier, Supplier messageSupplier)
  // 断言 executable或supplier在timeout之内执行完成，会重开线程执行，如果超时会对执行线程做打断处理
  assertTimeoutPreemptively(Duration timeout, Executable executable)
  assertTimeoutPreemptively(Duration timeout, Executable executable, String message)
  assertTimeoutPreemptively(Duration timeout, Executable executable, Supplier messageSupplier)
  T assertTimeoutPreemptively(Duration timeout, ThrowingSupplier supplier)
  T assertTimeoutPreemptively(Duration timeout, ThrowingSupplier supplier, String message)
  T assertTimeoutPreemptively(Duration timeout, ThrowingSupplier supplier, Supplier messageSupplier)
  T assertTimeoutPreemptively(Duration timeout, ThrowingSupplier supplier, Supplier messageSupplier, Assertions.TimeoutFailureFactory failureFactory)

  // 断言所有可执行代码不抛出异常
  assertAll(String heading, Collection executables)
  assertAll(String heading, Stream executables)
  assertAll(String heading, Executable... executables)
  assertAll(Collection executables)
  assertAll(Stream executables)
  assertAll(Executable... executables)
    示例：

        assertAll("properties",
            () -> {
                String firstName = person.getFirstName();
                assertNotNull(firstName);
                assertAll("first name",
                    () -> assertTrue(firstName.startsWith("J")),
                    () -> assertTrue(firstName.endsWith("e"))
                );
            },
            () -> {
                // Grouped assertion, so processed independently
                // of results of first name assertions.
                String lastName = person.getLastName();
                assertNotNull(lastName);
            }
        );

  // 抛出失败
  fail()
  fail(String message)
  fail(String message, Throwable cause)
  fail(Throwable cause)
  fail(Supplier messageSupplier)

  第三方断言库

    尽管JUnit Jupiter提供的断言工具对于许多测试场景来说已经足够了，但有时还需要更多的和额外的功能，如matchers(匹配器)。
    JUnit团队建议使用诸如AssertJ、Hamcrest、Truth等第三方断言库，因此开发人员可以自由使用他们选择的断言库。
    例如，可以使用 matchers(匹配器)和一个 fluent(流式调用) API的组合使断言更具描述性和可读性。
    然而，JUnit Jupiter的断言类没有像JUnit 4的 org.junit.Assert 那样提供一个assertThat() 方法，此方法接受Hamcrest Matcher。
    鼓励开发人员使用第三方断言库提供的对 matchers(匹配器)的内置支持。

    例如使用Hamcrest的库：

      assertThat(calculator.subtract(4, 1), is(equalTo(3)));

    例如使用assertJ的库：

	  assertThat(res.getContent()).isEqualTo(valueList);

    当然，可以继续使用基于JUnit 4遗留的编程模型 org.junit.Assert#assertThat 进行测试。

假设(Assumptions)

  JUnit Jupiter 附带了JUnit 4提供的Assumptions(假设)方法的子集，并添加了一些可以很好地使用Java 8 lambdas的方法。
  所有的JUnit Jupiter假设都是 org.junit.jupiter.api.Assumptions 类的静态方法。

  与失败的断言形成直接对比的是，失败的假设不会导致测试失败；相反，一个失败的假设会导致测试中止。

  // 假设 assumption或assumptionSupplier为true，如果成立则继续执行，否则退出测试方法。
  assumeTrue(boolean assumption)
  assumeTrue(boolean assumption, String message)
  assumeTrue(boolean assumption, Supplier messageSupplier)
  assumeTrue(BooleanSupplier assumptionSupplier)
  assumeTrue(BooleanSupplier assumptionSupplier, String message)
  assumeTrue(BooleanSupplier assumptionSupplier, Supplier messageSupplier)
  // 相反假设
  assumeFalse，参数与assumeTrue一致

  // 假设 assumption或assumptionSupplier为true，如果成立则执行executable，否则什么都不做
  assumingThat(boolean assumption, Executable executable)
  assumingThat(BooleanSupplier assumptionSupplier, Executable executable)

  // 退出测试方法
  abort()
  abort(String message)
  abort(String message)

条件测试执行(Conditional Test Execution)

  禁用
    在测试类或者方法上使用@Disabled或@Disabled("some msg")
  按操作系统和架构进行启用或禁用
    @EnabledOnOs(MAC)
    @EnabledOnOs({ LINUX, MAC })
    @EnabledOnOs(architectures = "aarch64")
    @EnabledOnOs(value = MAC, architectures = "aarch64")
    @DisabledOnOs(WINDOWS)
    @DisabledOnOs(architectures = "x86_64")
    @DisabledOnOs(value = MAC, architectures = "aarch64")
  按JAVA运行时启用或禁用
    @EnabledOnJre(JAVA_8)
    @EnabledOnJre({ JAVA_9, JAVA_10 })
    @EnabledForJreRange(min = JAVA_9, max = JAVA_11)
    @EnabledForJreRange(min = JAVA_9)
    @EnabledForJreRange(max = JAVA_11)
    @DisabledOnJre(JAVA_9)
    @DisabledForJreRange(min = JAVA_9, max = JAVA_11)
    @DisabledForJreRange(min = JAVA_9)
    @DisabledForJreRange(max = JAVA_11)
  按是否使用GraalVM本地镜像进行启用或禁用
    @EnabledInNativeImage
    @DisabledInNativeImage
  按系统属性值进行启用或禁用
    @EnabledIfSystemProperty(named = "os.arch", matches = ".*64.*")
    @DisabledIfSystemProperty(named = "ci-server", matches = "true")
  按环境变量值进行启用或禁用
    @EnabledIfEnvironmentVariable(named = "ENV", matches = "staging-server")
    @DisabledIfEnvironmentVariable(named = "ENV", matches = ".*development.*")
  使用自定义条件

    @EnabledIf("customCondition")
	@DisabledIf("example.ExternalCondition#customCondition")
	boolean customCondition() {
      return true;
    }
	class ExternalCondition {
      static boolean customCondition() {
        return true;
      }
    }

标签和过滤(Tagging and Filtering)

  可以对测试类和方法进行标记。这些标记稍后可以用于过滤 test discovery and execution(测试发现和执行)。

  标签的语法规则(Syntax Rules for Tags)
    标记不能为null或blank
    一个修剪标签(trimmed tag)不能包含空格
    一个修剪标签(trimmed tag)不能包含ISO控制字符
    一个修剪标签(trimmed tag)不能包含以下保留字符
      ,、(、)、&、|、!

  标签表达式
    product
    catalog | shipping
    catalog & shipping
    product & !end-to-end
    (micro | integration) & (product | shipping)
    any() 表示注解了任意标签的类/方法
    none() 表示未注解标签的类/方法
 

测试执行顺序

  测试方法执行顺序

    在测试类上使用@TestMethodOrder指定类中测试方法的执行顺序

MethodOrderer.DisplayName 根据测试方法的显示名称对其进行字母数字排序
MethodOrderer.MethodName 根据测试方法的名称和形式参数列表对测试方法进行字母数字排序
MethodOrderer.OrderAnnotation 根据@Order注解指定的值对测试方法进行数字排序
MethodOrderer.Random 伪随机订购测试方法，并支持自定义种子的配置
MethodOrderer.Alphanumeric 根据测试方法的名称和形式参数列表对测试方法进行字母数字排序；5.7开始使用MethodName

    设置默认
      junit.jupiter.testmethod.order.default = org.junit.jupiter.api.MethodOrderer$OrderAnnotation

    @TestMethodOrder(OrderAnnotation.class)
    class OrderedTestsDemo {
        @Test
        @Order(1)
        void nullValues() {
        }
        @Test
        @Order(2)
        void emptyValues() {
        }
        @Test
        @Order(3)
        void validValues() {
        }
    }

  测试类执行顺序

    内置排序类型

ClassOrderer.ClassName 根据测试类的完全限定类名对其进行字母数字排序
ClassOrderer.DisplayName 根据测试类的显示名称对其进行字母数字排序
ClassOrderer.OrderAnnotation 根据@Order注解指定的值对测试类进行数字排序
ClassOrderer.Random 伪随机订购测试类，并支持自定义种子的配置

    设置全局排序类型
      junit.jupiter.testclass.order.default = org.junit.jupiter.api.ClassOrderer$OrderAnnotation
    在一个类上使用@TestClassOrder注解，只会影响其@Nested类的执行顺序

      @TestClassOrder(ClassOrderer.OrderAnnotation.class)
      class OrderedNestedTestClassesDemo {
          @Nested
          @Order(1)
          class PrimaryTests {
              @Test
              void test1() {
              }
          }
          @Nested
          @Order(2)
          class SecondaryTests {
              @Test
              void test2() {
              }
          }
      }

测试实例生命周期(Test Instance Lifecycle)  

  为了隔离的执行单独的测试方法，并且为了避免由于可变测试实例状态而产生的意外副作用，JUnit在执行每个测试方法之前创建了一个新的测试类的实例。
  这个“per-method”测试实例生命周期是JUnit Jupiter上的默认行为，类似于所有以前的JUnit版本。

  如果您希望JUnit Jupiter在同一个测试实例上执行所有的测试方法，只需用@Testinstance(Lifecycle.PER_CLASS)注解您的测试类。
  当使用此模式时，每个测试类将创建一个新的测试实例。
  如果您的测试方法依赖于实例变量存储的状态，那么您可能需要在@BeforeEach 或 @AfterEach 方法中重置该状态。

  设置默认
    junit.jupiter.testinstance.lifecycle.default=per_class
 

嵌套测试(Nested Tests)

  嵌套测试赋予测试者更多的能力来表达几组测试之间的关系。
  这样的嵌套测试利用了Java的嵌套类，并促进了对测试结构的分层思考。

  只有非静态嵌套类(即内部类)可以充当@Nested测试类。
  嵌套可以是任意深度的，而那些内部类被认为是测试类家族的完整成员，只有一个例外:@BeforeAll 和 @AfterAll 方法在默认情况下不工作。
  原因是在Java16之前不允许内部类中的 static 成员。
  但是，可以通过使用@TestInstance(Lifecycle.PER_CLASS)注解@Nested的测试类来规避这个限制。

  @DisplayName("A stack")
  class TestingAStackDemo {
  
      Stack stack;
  
      @Test
      @DisplayName("is instantiated with new Stack()")
      void isInstantiatedWithNew() {
          new Stack<>();
      }
  
      @Nested
      @DisplayName("when new")
      class WhenNew {
  
          @BeforeEach
          void createNewStack() {
              stack = new Stack<>();
          }
  
          @Test
          @DisplayName("is empty")
          void isEmpty() {
              assertTrue(stack.isEmpty());
          }
  
          @Test
          @DisplayName("throws EmptyStackException when popped")
          void throwsExceptionWhenPopped() {
              assertThrows(EmptyStackException.class, stack::pop);
          }
  
          @Test
          @DisplayName("throws EmptyStackException when peeked")
          void throwsExceptionWhenPeeked() {
              assertThrows(EmptyStackException.class, stack::peek);
          }
  
          @Nested
          @DisplayName("after pushing an element")
          class AfterPushing {
  
              String anElement = "an element";
  
              @BeforeEach
              void pushAnElement() {
                  stack.push(anElement);
              }
  
              @Test
              @DisplayName("it is no longer empty")
              void isNotEmpty() {
                  assertFalse(stack.isEmpty());
              }
  
              @Test
              @DisplayName("returns the element when popped and is empty")
              void returnElementWhenPopped() {
                  assertEquals(anElement, stack.pop());
                  assertTrue(stack.isEmpty());
              }
  
              @Test
              @DisplayName("returns the element when peeked but remains not empty")
              void returnElementWhenPeeked() {
                  assertEquals(anElement, stack.peek());
                  assertFalse(stack.isEmpty());
              }
          }
      }
  } 
  
对构造函数和方法的依赖注入(Dependency Injection for Constructors and Methods)
 
  
  作为JUnit Jupiter的主要变化之一，测试构造函数和方法现在都允许有参数。这允许更大的灵活性，并支持构造函数和方法的依赖注入。
 
  
  ParameterResolver (参数解析器)定义了用于测试扩展的API，它希望在运行时动态解析参数。
   如果测试构造函数或@Test, @TestFactory, @BeforeEach, @AfterEach, @BeforeAll 或者 @AfterAll方法接受一个参数，那么参数必须在运行时由注册的 ParameterResolver (参数解析器)解析。
   目前有三个内置的解析器是自动注册的。
    TestInfoParameterResolver(测试信息参数解析器)
       如果一个方法的参数类型是 TestInfo ， TestInfoParameterResolver将供应TestInfo对应当前测试的实例作为参数的值。
       然后，TestInfo可以用来检索关于当前测试的信息，比如测试的显示名称、测试类、测试方法或相关的标记。
       TestInfo作为一个从JUnit 4中替代TestName规则的替代程序。
 
  
      @DisplayName("TestInfo Demo")
      class TestInfoDemo {
          TestInfoDemo(TestInfo testInfo) {
              assertEquals("TestInfo Demo", testInfo.getDisplayName());
          }
          @BeforeEach
          void init(TestInfo testInfo) {
              String displayName = testInfo.getDisplayName();
              assertTrue(displayName.equals("TEST 1") || displayName.equals("test2()"));
          }
          @Test
          @DisplayName("TEST 1")
          @Tag("my-tag")
          void test1(TestInfo testInfo) {
              assertEquals("TEST 1", testInfo.getDisplayName());
              assertTrue(testInfo.getTags().contains("my-tag"));
          }
          @Test
          void test2() {
          }
      }
 
  
  RepetitionInfoParameterResolver(重复信息参数解析器)
 
  
    如果是@RepeatedTest，@BeforeEach, 或 @AfterEach里RepetitionInfo(重复信息)类型的参数,RepetitionInfoParameterResolver将提供一个RepetitionInfo实例。
     然后可以使用重复信息检索关于当前重复的信息以及相应的@RepeatedTest的重复次数。
     但是请注意,RepetitionInfoParameterResolver不能在@RepeatedTest的上下文以外注册。
 
  
  TestReporterParameterResolver(测试报告参数解析器)
 
  
    如果一个方法的参数类型是TestReporter, TestReporterParameterResolver将提供一个实例。
     可以使用TestReporter发布关于当前测试运行的额外数据。
     数据可以通过TestExecutionListener.reportingEntryPublished()消费,因此可以通过ide查看，也可以包括在报告中。
     在JUnit Jupiter 中，您应该使用TestReporter。
     在JUnit 4中您可以将信息打印到stdout或stderr。
     使用@RunWith(JUnitPlatform.class)将输出所有已报告的条目到stdout。
 
  
    class TestReporterDemo {
    
        @Test
        void reportSingleValue(TestReporter testReporter) {
            testReporter.publishEntry("a status message");
        }
        @Test
        void reportKeyValuePair(TestReporter testReporter) {
            testReporter.publishEntry("a key", "a value");
        }
        @Test
        void reportMultipleKeyValuePairs(TestReporter testReporter) {
            Map values = new HashMap<>();
            values.put("user name", "dk38");
            values.put("award year", "1974");
    
            testReporter.publishEntry(values);
        }
    }
 
  
  其他参数解析器必须通过通过@ExtendWith注册适当的扩展(extensions)来显式启用。
 
  
    @ExtendWith(MockitoExtension.class)
    class MyMockitoTest {
        @BeforeEach
        void init(@Mock Person person) {
            when(person.getName()).thenReturn("Dilbert");
        }
        @Test
        void simpleTestWithInjectedMock(@Mock Person person) {
            assertEquals("Dilbert", person.getName());
        }
    }
 
  
测试接口和默认方法(Test Interfaces and Default Methods)
 
  
  JUnit Jupiter 允许@Test, @RepeatedTest, @ParameterizedTest, @TestFactory, @TestTemplate, @BeforeEach, @AfterEach在接口 default 方法上声明。
   如果测试接口或测试类被用@TestInstance(Lifecycle.PER_CLASS)注解，@BeforeAll 和 @AfterAll可以在测试接口static方法或接口default 方法中声明。
   在继承接口的测试类执行时，从接口继承的测试方法也会执行
 
  
  @ExtendWith 和 @Tag可以在测试接口上声明，以便实现接口的类自动继承其标记和扩展。
 
  
重复测试(Repeated Tests)
 
  
  JUnit Jupiter 通过使用 @RepeatedTest 来注解一个方法并指定所需重复的总数，从而提供了重复测试指定次数的能力。
   重复测试的每次调用行为都类似于执行常规的@Test方法，完全支持相同的生命周期回调和扩展。
 
  
  可以通过@RepeatedTest注解的name属性为每次重复配置一个自定义显示名称。
   显示名称可以是由静态文本和动态占位符组合而成的模式。目前支持以下占位符。
     {displayName}: 显示@RepeatedTest方法的名称
     {currentRepetition}: 当前重复计数
     {totalRepetitions}: 重复的总数
 
  
  如果你想要显示的名称@RepeatedTest方法包含一种重复的名称,您可以定义自己的自定义模式或使用预定义的RepeatedTest.LONG_DISPLAY_NAME模式。
   后者等于"{displayName} :: repetition {currentRepetition} of {totalRepetitions}"
 
  
  为了检索关于当前重复的信息和编程的总重复次数，开发人员可以选择将 RepetitionInfo 的实例注入到 @RepeatedTest ， @BeforeEach ，或 @AfterEach 方法。
 
  
  class RepeatedTestsDemo {
  
      private Logger logger = // ...
  
      @BeforeEach
      void beforeEach(TestInfo testInfo, RepetitionInfo repetitionInfo) {
          int currentRepetition = repetitionInfo.getCurrentRepetition();
          int totalRepetitions = repetitionInfo.getTotalRepetitions();
          String methodName = testInfo.getTestMethod().get().getName();
          logger.info(String.format("About to execute repetition %d of %d for %s", //
              currentRepetition, totalRepetitions, methodName));
      }
  
      @RepeatedTest(10)
      void repeatedTest() {
          // ...
      }
  
      @RepeatedTest(5)
      void repeatedTestWithRepetitionInfo(RepetitionInfo repetitionInfo) {
          assertEquals(5, repetitionInfo.getTotalRepetitions());
      }
  
      @RepeatedTest(value = 1, name = "{displayName} {currentRepetition}/{totalRepetitions}")
      @DisplayName("Repeat!")
      void customDisplayName(TestInfo testInfo) {
          assertEquals("Repeat! 1/1", testInfo.getDisplayName());
      }
  
      @RepeatedTest(value = 1, name = RepeatedTest.LONG_DISPLAY_NAME)
      @DisplayName("Details...")
      void customDisplayNameWithLongPattern(TestInfo testInfo) {
          assertEquals("Details... :: repetition 1 of 1", testInfo.getDisplayName());
      }
  
      @RepeatedTest(value = 5, name = "Wiederholung {currentRepetition} von {totalRepetitions}")
      void repeatedTestInGerman() {
          // ...
      }
  }
 
  
参数化测试(Parameterized Tests)
 
  
  参数化测试可以用不同的参数多次运行测试。
   它们像普通的@Test方法一样被声明，但是使用@ParameterizedTest注解。
   此外，您必须声明至少一个参数源，它将为每次调用提供参数。
   
   为了使用参数化测试，您需要添加 junit-jupiter-params构件的依赖项。
 
  
  @ValueSource
 
  
    可能是最简单的来源之一。它允许您指定一组原始类型的文字，并且只能用于每次调用时提供一个参数。
     支持的类型有short,byte,int,long,float,double,char,boolean,String,Class
 
  
      @ParameterizedTest
      @ValueSource(strings = { "racecar", "radar", "able was I ere I saw elba" })
      void palindromes(String candidate) {
          assertTrue(StringUtils.isPalindrome(candidate));
      }
 
  
  @NullSource
 
  
    为带注释的@ParameterizedTest方法提供一个null参数
     不能用于基础类型，比如int
 
  
  @EmptySource
 
  
    为带注释的@ParameterizedTest方法提供了一个空参数，
     用于以下类型的参数：String、List、Set、Map、基元数组(例如int[]、char[]等)、对象数组(例如String[]、Integer[]等)。
     不支持上述类型的子类型
 
  
  @NullAndEmptySource
 
  
    组合了@NullSource和@EmptySource功能的组合注解
 
  
  可以组合使用@NullSource, @EmptySource和@ValueSource
 
  
    @ParameterizedTest
    @NullSource
    @EmptySource
    @ValueSource(strings = { " ", "   ", "\t", "\n" })
    void nullEmptyAndBlankStrings(String text) {
        assertTrue(text == null || text.trim().isEmpty());
    }
 
  
  @EnumSource
 
  
    提供了一种方便的方法来使用Enum常量。
     可选的value参数，允许指定使用Enum。默认将使用方法第一个入参的类型。
     可选的names参数，允许指定使用哪些常量。默认使用全部。
     可选的mode参数，允许更细的控制。
 
  
      @ParameterizedTest
      @EnumSource(ChronoUnit.class)
      void testWithEnumSource(TemporalUnit unit) {
          assertNotNull(unit);
      }
      @ParameterizedTest
      @EnumSource
      void testWithEnumSourceWithAutoDetection(ChronoUnit unit) {
          assertNotNull(unit);
      }
      @ParameterizedTest
      @EnumSource(names = { "DAYS", "HOURS" })
      void testWithEnumSourceInclude(ChronoUnit unit) {
          assertTrue(EnumSet.of(ChronoUnit.DAYS, ChronoUnit.HOURS).contains(unit));
      }
      @ParameterizedTest
      @EnumSource(mode = EXCLUDE, names = { "ERAS", "FOREVER" })
      void testWithEnumSourceExclude(ChronoUnit unit) {
          assertFalse(EnumSet.of(ChronoUnit.ERAS, ChronoUnit.FOREVER).contains(unit));
      }
      @ParameterizedTest
      @EnumSource(mode = MATCH_ALL, names = "^.*DAYS$")
      void testWithEnumSourceRegex(ChronoUnit unit) {
          assertTrue(unit.name().endsWith("DAYS"));
      }
 
  
  @MethodSource
 
  
    允许您引用测试类的一个或多个工厂方法。这些方法必须返回流(Stream)、迭代(Iterable)、迭代器(Iterator)或参数数组。
     此外，这些方法不能接受任何参数。默认情况下，这些方法必须是静态的(static )，除非测试类被@TestInstance(Lifecycle.PER_CLASS)注解
 
  
      @ParameterizedTest
      @MethodSource("stringProvider")
      void testWithExplicitLocalMethodSource(String argument) {
          assertNotNull(argument);
      }
      static Stream stringProvider() {
          return Stream.of("apple", "banana");
      }
 
  
    静态工厂方法可以通过提供其完全限定的方法名称来引用
       @MethodSource("example.StringsProviders#tinyStrings")
 
  
    如果未在@MethodSource内写方法名，则会查找和当前测试方法同名的工厂方法
 
  
      @ParameterizedTest
      @MethodSource
      void testWithDefaultLocalMethodSource(String argument) {
          assertNotNull(argument);
      }
      static Stream testWithDefaultLocalMethodSource() {
          return Stream.of("apple", "banana");
      }
 
  
    如果一个测试方法声明多个参数，您则需要返回一个Arguments实例的集合或流
 
  
      @ParameterizedTest
      @MethodSource("stringIntAndListProvider")
      void testWithMultiArgMethodSource(String str, int num, List list) {
          assertEquals(5, str.length());
          assertTrue(num >=1 && num <=2);
          assertEquals(2, list.size());
      }
      static Stream stringIntAndListProvider() {
          return Stream.of(
              arguments("apple", 1, Arrays.asList("a", "b")),
              arguments("lemon", 2, Arrays.asList("x", "y"))
          );
      }
 
  
  @CsvSource
 
  
    允许您以逗号分隔值来表达参数列表
     @CsvSource使用单引号作(')为其引用字符。
 
  
      @ParameterizedTest
      @CsvSource({
          "apple,         1",
          "banana,        2",
          "'lemon, lime', 0xF1",
          "strawberry,    700_000"
      })
      void testWithCsvSource(String fruit, int rank) {
          assertNotNull(fruit);
          assertNotEquals(0, rank);
      }
 
  
    表达式
       @CsvSource({ "apple, banana" })        参数拆分："apple", "banana"
       @CsvSource({ "apple, 'lemon, lime'" }) 参数拆分："apple", "lemon, lime"
       @CsvSource({ "apple, ''" })            参数拆分："apple", ""
       @CsvSource({ "apple, " })              参数拆分："apple", null
       @CsvSource(value = { "apple, banana, NIL" }, nullValues = "NIL") 参数拆分："apple", "banana", null
       @CsvSource(value = { " apple , banana" }, ignoreLeadingAndTrailingWhitespace = false) 参数拆分：" apple ", " banana"
 
  
  @CsvFileSource
 
  
    允许您从类路径中使用CSV文件。
     CSV文件中的每一行都产生一个参数化测试的调用。
     @CsvFileSource使用了双引号(")作为引用字符。
     参数resources指定基于resources文件夹的路径
     参数files指定基于项目根目录的路径
     参数numLinesToSkip指定忽略行数
     参数delimiter/delimiterString可以指定字段分隔符
     参数useHeadersInDisplayName指定是否在显示名称中使用数据
 
  
      @ParameterizedTest
      @CsvFileSource(resources = "/two-column.csv", numLinesToSkip = 1)
      void testWithCsvFileSourceFromClasspath(String country, int reference) {
          assertNotNull(country);
          assertNotEquals(0, reference);
      }
      
      @ParameterizedTest
      @CsvFileSource(files = "src/test/resources/two-column.csv", numLinesToSkip = 1)
      void testWithCsvFileSourceFromFile(String country, int reference) {
          assertNotNull(country);
          assertNotEquals(0, reference);
      }
      
      @ParameterizedTest(name = "[{index}] {arguments}")
      @CsvFileSource(resources = "/two-column.csv", useHeadersInDisplayName = true)
      void testWithCsvFileSourceAndHeaders(String country, int reference) {
          assertNotNull(country);
          assertNotEquals(0, reference);
      }
 
  
  @ArgumentsSource
 
  
    可以使用@ArgumentsSource指定自定义、可重用的ArgumentsProvider
 
  
      @ParameterizedTest
      @ArgumentsSource(MyArgumentsProvider.class)
      void testWithArgumentsSource(String argument) {
          assertNotNull(argument);
      }
      public class MyArgumentsProvider implements ArgumentsProvider {
          @Override
          public Stream provideArguments(ExtensionContext context) {
              return Stream.of("apple", "banana").map(Arguments::of);
          }
      }
 
  
  参数转换(Argument Conversion)
 
  
    隐式转换(Implicit Conversion)
       为了支持像@CsvSource这样的用例，JUnit Jupiter 提供了一些内置隐式类型转换器。转换过程取决于每个方法参数的声明类型。
 
  
      boolean/Boolean          例如："true" → true
       byte/Byte                例如："15", "0xF", or "017" → (byte) 15
       char/Character           例如："o" → 'o'
       short/Short              例如："15", "0xF", or "017" → (short) 15
       int/Integer              例如："15", "0xF", or "017" → 15
       long/Long                例如："15", "0xF", or "017" → 15L
       float/Float              例如："1.0" → 1.0f
       double/Double            例如："1.0" → 1.0d
       Enum subclass            例如："SECONDS" → TimeUnit.SECONDS
       java.io.File             例如："/path/to/file" → new File("/path/to/file")
       java.lang.Class          例如："java.lang.Integer" → java.lang.Integer.class (use $ for nested classes, e.g. "java.lang.Thread$State")
       java.lang.Class          例如："byte" → byte.class (primitive types are supported)
       java.lang.Class          例如："char[]" → char[].class (array types are supported)
       java.math.BigDecimal     例如："123.456e789" → new BigDecimal("123.456e789")
       java.math.BigInteger     例如："1234567890123456789" → new BigInteger("1234567890123456789")
       java.net.URI             例如："https://junit.org/" → URI.create("https://junit.org/")
       java.net.URL             例如："https://junit.org/" → URI.create("https://junit.org/").toURL()
       java.nio.charset.Charset 例如："UTF-8" → Charset.forName("UTF-8")
       java.nio.file.Path       例如："/path/to/file" → Paths.get("/path/to/file")
       java.time.Duration       例如："PT3S" → Duration.ofSeconds(3)
       java.time.Instant        例如："1970-01-01T00:00:00Z" → Instant.ofEpochMilli(0)
       java.time.LocalDateTime  例如："2017-03-14T12:34:56.789" → LocalDateTime.of(2017, 3, 14, 12, 34, 56, 789_000_000)
       java.time.LocalDate      例如："2017-03-14" → LocalDate.of(2017, 3, 14)
       java.time.LocalTime      例如："12:34:56.789" → LocalTime.of(12, 34, 56, 789_000_000)
       java.time.MonthDay       例如："--03-14" → MonthDay.of(3, 14)
       java.time.OffsetDateTime 例如："2017-03-14T12:34:56.789Z" → OffsetDateTime.of(2017, 3, 14, 12, 34, 56, 789_000_000, ZoneOffset.UTC)
       java.time.OffsetTime     例如："12:34:56.789Z" → OffsetTime.of(12, 34, 56, 789_000_000, ZoneOffset.UTC)
       java.time.Period         例如："P2M6D" → Period.of(0, 2, 6)
       java.time.YearMonth      例如："2017-03" → YearMonth.of(2017, 3)
       java.time.Year           例如："2017" → Year.of(2017)
       java.time.ZonedDateTime  例如："2017-03-14T12:34:56.789Z" → ZonedDateTime.of(2017, 3, 14, 12, 34, 56, 789_000_000, ZoneOffset.UTC)
       java.time.ZoneId         例如："Europe/Berlin" → ZoneId.of("Europe/Berlin")
       java.time.ZoneOffset     例如："+02:30" → ZoneOffset.ofHoursMinutes(2, 30)
       java.util.Currency       例如："JPY" → Currency.getInstance("JPY")
       java.util.Locale         例如："en" → new Locale("en")
       java.util.UUID           例如："d043e930-7b3b-48e3-bdbe-5a3ccfb833db" → UUID.fromString("d043e930-7b3b-48e3-bdbe-5a3ccfb833db")
 
  
      如果参数类型中定义了接收单个字符串的构造方法或者工厂方法，也可以从字符串转对象。
       如果发现多个工厂方法，它们将被忽略。
       如果发现了工厂方法和工厂构造函数，则将使用工厂方法而不是构造函数。
 
  
	    @ParameterizedTest
        @ValueSource(strings = "42 Cats")
        void testWithImplicitFallbackArgumentConversion(Book book) {
            assertEquals("42 Cats", book.getTitle());
        }
        public class Book {
            private final String title;
            private Book(String title) {
                this.title = title;
            }
            public static Book fromTitle(String title) {
                return new Book(title);
            }
            public String getTitle() {
                return this.title;
            }
        }
 
  
    显式转换(Explicit Conversion)
 
  
      可以显式地指定一个ArgumentConverter来使用@ConvertWith注解来使用某个参数
 
  
        @ParameterizedTest
        @EnumSource(ChronoUnit.class)
        void testWithExplicitArgumentConversion(@ConvertWith(ToStringArgumentConverter.class) String argument) {
            assertNotNull(ChronoUnit.valueOf(argument));
        }
        public class ToStringArgumentConverter extends SimpleArgumentConverter {
            @Override
            protected Object convert(Object source, Class targetType) {
                assertEquals(String.class, targetType, "Can only convert to String");
                if (source instanceof Enum) {
                    return ((Enum) source).name();
                }
                return String.valueOf(source);
            }
        }
 
  
      如果转换器仅用于将一种类型转换为另一种类型，则可以扩展TypedArgumentConverter以避免类型检查。
 
  
        public class ToLengthArgumentConverter extends TypedArgumentConverter {
            protected ToLengthArgumentConverter() {
                super(String.class, Integer.class);
            }
            @Override
            protected Integer convert(String source) {
                return (source != null ? source.length() : 0);
            }
        }
 
  
      显式参数转换是由测试者实现的。因此,junit-jupiter-params只提供了一个显式参数转换类：JavaTimeArgumentConverter,也可以作为一种参考实现。
 
  
        @ParameterizedTest
        @ValueSource(strings = { "01.01.2017", "31.12.2017" })
        void testWithExplicitJavaTimeConverter(@JavaTimeConversionPattern("dd.MM.yyyy") LocalDate argument) {
            assertEquals(2017, argument.getYear());
        }
 
  
  参数聚合(Argument Conversion)
 
  
    可以使用ArgumentsAccessor访问多个参数
 
  
      @ParameterizedTest
      @CsvSource({
          "Jane, Doe, F, 1990-05-20",
          "John, Doe, M, 1990-10-22"
      })
      void testWithArgumentsAccessor(ArgumentsAccessor arguments) {
          Person person = new Person(arguments.getString(0),
                                     arguments.getString(1),
                                     arguments.get(2, Gender.class),
                                     arguments.get(3, LocalDate.class));

          if (person.getFirstName().equals("Jane")) {
              assertEquals(Gender.F, person.getGender());
          }
          else {
              assertEquals(Gender.M, person.getGender());
          }
          assertEquals("Doe", person.getLastName());
          assertEquals(1990, person.getDateOfBirth().getYear());
      }
 
  
    可以使用@AggregateWith指定自定义参数聚合类
 
  
      @ParameterizedTest
      @CsvSource({
          "Jane, Doe, F, 1990-05-20",
          "John, Doe, M, 1990-10-22"
      })
      void testWithArgumentsAggregator(@AggregateWith(PersonAggregator.class) Person person) {
          // perform assertions against person
      }
      public class PersonAggregator implements ArgumentsAggregator {
          @Override
          public Person aggregateArguments(ArgumentsAccessor arguments, ParameterContext context) {
              return new Person(arguments.getString(0),
                                arguments.getString(1),
                                arguments.get(2, Gender.class),
                                arguments.get(3, LocalDate.class));
          }
      }
 
  
  自定义显示的名字(Customizing Display Names)
 
  
    @ParameterizedTest注解的name属性来定制调用显示名称
     {displayName}         表示当前方法的显示名
     {index}                     表示当前条数,从1开始
     {arguments}            表示全部参数值,使用逗号分隔
     {argumentsWithNames}  表示包含参数名的全部参数值,使用逗号分隔
     {0}, {1}, …               表示具体的第几个参数值
 
  
      @DisplayName("Display name of container")
      @ParameterizedTest(name = "{index} ==> first=''{0}'', second={1}")
      @CsvSource({ "foo, 1", "bar, 2", "'baz, qux', 3" })
      void testWithCustomDisplayNames(String first, int second) {
      }
 
  
  生命周期和互操作性(Lifecycle and Interoperability)
 
  
    参数化测试的每次调用都有与常规的@Test方法相同的生命周期。例如，@BeforeEach方法将在每次调用之前执行。
     与动态测试(Dynamic Tests)类似，调用将在IDE的测试树中逐一显示。
     您可以在同一个测试类中混合常规的@Test方法和@ParameterizedTest方法。
 
  
    可以使用@ParameterizedTest方法使用ParameterResolver扩展。但是，由参数源解决的方法参数需要首先出现在参数列表中。
     由于测试类可能包含常规测试，以及带有不同参数列表的参数化测试，来自参数源的值不会在生命周期方法(例如@BeforeEach)和测试类构造函数中解析。
 
  
      @BeforeEach
      void beforeEach(TestInfo testInfo) {
          // ...
      }
      @ParameterizedTest
      @ValueSource(strings = "foo")
      void testWithRegularParameterResolver(String argument, TestReporter testReporter) {
          testReporter.publishEntry("argument", argument);
      }
      @AfterEach
      void afterEach(TestInfo testInfo) {
          // ...
      }
 
  
测试模板(Test Templates)  
 
  
  @TestTemplate方法不是常规的测试用例，而是测试用例的模板。
   根据注册提供者返回的调用上下文的数量，它被设计为多次调用。
   它必须使用与注册TestTemplateInvocationContextProvider的扩展。
   测试模板方法的每次调用都像一个常规的@Test方法的执行，完全支持相同的生命周期回调和扩展。
 
  
    final List fruits = Arrays.asList("apple", "banana", "lemon");
    
    @TestTemplate
    @ExtendWith(MyTestTemplateInvocationContextProvider.class)
    void testTemplate(String fruit) {
        assertTrue(fruits.contains(fruit));
    }
    
    public class MyTestTemplateInvocationContextProvider
            implements TestTemplateInvocationContextProvider {
    
        @Override
        public boolean supportsTestTemplate(ExtensionContext context) {
            return true;
        }
        @Override
        public Stream provideTestTemplateInvocationContexts(
                ExtensionContext context) {
    
            return Stream.of(invocationContext("apple"), invocationContext("banana"));
        }
        private TestTemplateInvocationContext invocationContext(String parameter) {
            return new TestTemplateInvocationContext() {
                @Override
                public String getDisplayName(int invocationIndex) {
                    return parameter;
                }
                @Override
                public List getAdditionalExtensions() {
                    return Collections.singletonList(new ParameterResolver() {
                        @Override
                        public boolean supportsParameter(ParameterContext parameterContext,
                                ExtensionContext extensionContext) {
                            return parameterContext.getParameter().getType().equals(String.class);
                        }
    
                        @Override
                        public Object resolveParameter(ParameterContext parameterContext,
                                ExtensionContext extensionContext) {
                            return parameter;
                        }
                    });
                }
            };
        }
    }
 
  
动态测试(Dynamic Tests)
 
  
  @TestFactory方法本身并不是一个测试用例，而是一个用于测试用例的工厂。因此，动态测试是工厂的产品。
   @TestFactory方法必须返回动态节点实例的流(Stream)、集合(Collection)、迭代器(Iterable、Iterator)的DynamicNode实例，DynamicNode的实例子类是DynamicContainer和DynamicTest。
   DynamicContainer实例由一个显示名称和一个动态子节点列表组成，可以创建任意嵌套的动态节点层次结构。然后，DynamicTest实例将被延迟执行，从而支持动态甚至不确定的测试用例生成。
   DynamicTest是在运行时生成的测试用例。它由一个显示名称组成。Executable是一个@FunctionalInterface，这意味着动态测试的实现可以作为lambda表达式或方法引用。
 
  
  @TestFactory返回的任何流(Stream)都将通过调用stream.close()来适当地关闭，这样就可以安全地使用诸如Files.lines()这样的资源。
   @TestFactory方法不能是私有(private)的或静态的(static)，也可以选择性地声明由参数解析器(ParameterResolvers)解析的参数。
 
  
  动态测试的执行生命周期与标准@Test用例的执行生命周期完全不同。
   对于单个动态测试没有生命周期回调。这意味着@BeforeEach和@AfterEach方法及其相应的扩展回调是为@TestFactory方法执行的，而不是为每个动态测试执行的。
 
  
    class DynamicTestsDemo {
    
        private final Calculator calculator = new Calculator();
    
        // This will result in a JUnitException!
        @TestFactory
        List dynamicTestsWithInvalidReturnType() {
            return Arrays.asList("Hello");
        }
    
        @TestFactory
        Collection dynamicTestsFromCollection() {
            return Arrays.asList(
                dynamicTest("1st dynamic test", () -> assertTrue(isPalindrome("madam"))),
                dynamicTest("2nd dynamic test", () -> assertEquals(4, calculator.multiply(2, 2)))
            );
        }
    
        @TestFactory
        Iterable dynamicTestsFromIterable() {
            return Arrays.asList(
                dynamicTest("3rd dynamic test", () -> assertTrue(isPalindrome("madam"))),
                dynamicTest("4th dynamic test", () -> assertEquals(4, calculator.multiply(2, 2)))
            );
        }
    
        @TestFactory
        Iterator dynamicTestsFromIterator() {
            return Arrays.asList(
                dynamicTest("5th dynamic test", () -> assertTrue(isPalindrome("madam"))),
                dynamicTest("6th dynamic test", () -> assertEquals(4, calculator.multiply(2, 2)))
            ).iterator();
        }
    
        @TestFactory
        DynamicTest[] dynamicTestsFromArray() {
            return new DynamicTest[] {
                dynamicTest("7th dynamic test", () -> assertTrue(isPalindrome("madam"))),
                dynamicTest("8th dynamic test", () -> assertEquals(4, calculator.multiply(2, 2)))
            };
        }
    
        @TestFactory
        Stream dynamicTestsFromStream() {
            return Stream.of("racecar", "radar", "mom", "dad")
                .map(text -> dynamicTest(text, () -> assertTrue(isPalindrome(text))));
        }
    
        @TestFactory
        Stream dynamicTestsFromIntStream() {
            // Generates tests for the first 10 even integers.
            return IntStream.iterate(0, n -> n + 2).limit(10)
                .mapToObj(n -> dynamicTest("test" + n, () -> assertTrue(n % 2 == 0)));
        }
    
        @TestFactory
        Stream generateRandomNumberOfTestsFromIterator() {
    
            // Generates random positive integers between 0 and 100 until
            // a number evenly divisible by 7 is encountered.
            Iterator inputGenerator = new Iterator() {
    
                Random random = new Random();
                int current;
    
                @Override
                public boolean hasNext() {
                    current = random.nextInt(100);
                    return current % 7 != 0;
                }
    
                @Override
                public Integer next() {
                    return current;
                }
            };
    
            // Generates display names like: input:5, input:37, input:85, etc.
            Function displayNameGenerator = (input) -> "input:" + input;
    
            // Executes tests based on the current input value.
            ThrowingConsumer testExecutor = (input) -> assertTrue(input % 7 != 0);
    
            // Returns a stream of dynamic tests.
            return DynamicTest.stream(inputGenerator, displayNameGenerator, testExecutor);
        }
    
        @TestFactory
        Stream dynamicTestsFromStreamFactoryMethod() {
            // Stream of palindromes to check
            Stream inputStream = Stream.of("racecar", "radar", "mom", "dad");
    
            // Generates display names like: racecar is a palindrome
            Function displayNameGenerator = text -> text + " is a palindrome";
    
            // Executes tests based on the current input value.
            ThrowingConsumer testExecutor = text -> assertTrue(isPalindrome(text));
    
            // Returns a stream of dynamic tests.
            return DynamicTest.stream(inputStream, displayNameGenerator, testExecutor);
        }
    
        @TestFactory
        Stream dynamicTestsFromStreamFactoryMethodWithNames() {
            // Stream of palindromes to check
            Stream> inputStream = Stream.of(
                    named("racecar is a palindrome", "racecar"),
                    named("radar is also a palindrome", "radar"),
                    named("mom also seems to be a palindrome", "mom"),
                    named("dad is yet another palindrome", "dad")
                );
    
            // Returns a stream of dynamic tests.
            return DynamicTest.stream(inputStream,
                text -> assertTrue(isPalindrome(text)));
        }
    
        @TestFactory
        Stream dynamicTestsWithContainers() {
            return Stream.of("A", "B", "C")
                .map(input -> dynamicContainer("Container " + input, Stream.of(
                    dynamicTest("not null", () -> assertNotNull(input)),
                    dynamicContainer("properties", Stream.of(
                        dynamicTest("length > 0", () -> assertTrue(input.length() > 0)),
                        dynamicTest("not empty", () -> assertFalse(input.isEmpty()))
                    ))
                )));
        }
    
        @TestFactory
        DynamicNode dynamicNodeSingleTest() {
            return dynamicTest("'pop' is a palindrome", () -> assertTrue(isPalindrome("pop")));
        }
    
        @TestFactory
        DynamicNode dynamicNodeSingleContainer() {
            return dynamicContainer("palindromes",
                Stream.of("racecar", "radar", "mom", "dad")
                    .map(text -> dynamicTest(text, () -> assertTrue(isPalindrome(text)))
            ));
        }
    
    }
 
  
超时(Timeouts)
 
  
  在测试、测试工厂、测试模板或生命周期方法上使用@Timeout注解,超时后会失败
   默认单位为秒,可以配置
 
  
    class TimeoutDemo {
        @BeforeEach
        @Timeout(5)
        void setUp() {
            // fails if execution time exceeds 5 seconds
        }
        @Test
        @Timeout(value = 500, unit = TimeUnit.MILLISECONDS)
        void failsIfExecutionTimeExceeds500Milliseconds() {
            // fails if execution time exceeds 500 milliseconds
        }
        @Test
        @Timeout(value = 500, unit = TimeUnit.MILLISECONDS, threadMode = ThreadMode.SEPARATE_THREAD)
        void failsIfExecutionTimeExceeds500MillisecondsInSeparateThread() {
            // fails if execution time exceeds 500 milliseconds, the test code is executed in a separate thread
        }
    }
 
  
  在类上使用@Timeout注解可以对类和@Nested类内的所有测试、测试工厂、测试模板方法起作用。
   在类上使用@Timeout注解对生命周期方法不起作用。
 
  
  在@TestFactory方法上声明@Timeout会检查工厂方法是否在指定的持续时间内返回，但不会验证工厂生成的每个DynamicTest的执行时间
 
  
  如果@TestTemplate方法上存在@Timeout，例如@RepeatedTest或@ParameterizedTest，则每次调用都会应用给定的超时。
 
  
  参数threadMode
 
  
 
    
    
 
     SAME_THREAD 
     在主线程执行测试，如果超时会有其他线程对主线程执行interrupt 
    
 
    
 
     SEPARATE_THREAD 
     在新的独立线程执行测试，如果执行的代码依赖于ThreadLocal存储，则这种行为可能会导致不希望的副作用。 
    
 
    
 
     INFERRED 
     根据junit.jupiter.execution.timeout.thread.mode.default的值决定，如果没有设置默认为SAME_THREAD 
    
 
    
  
 
  
  默认超时
 
  
    junit.jupiter.execution.timeout.default                     所有可测试方法和生命周期方法的默认超时
     junit.jupiter.execution.timeout.testable.method.default     所有可测试方法的默认超时
     junit.jupiter.execution.timeout.test.method.default         @Test方法的默认超时
     junit.jupiter.execution.timeout.testtemplate.method.default @TestTemplate方法的默认超时
     junit.jupiter.execution.timeout.testfactory.method.default  @TestFactory方法的默认超时
     junit.jupiter.execution.timeout.lifecycle.method.default    所有生命周期方法的默认超时
     junit.jupiter.execution.timeout.testfactory.method.default  @TestFactory方法的默认超时
     junit.jupiter.execution.timeout.beforeall.method.default    @BeforeAll方法的默认超时
     junit.jupiter.execution.timeout.beforeeach.method.default   @BeforeEach方法的默认超时
     junit.jupiter.execution.timeout.aftereach.method.default    @AfterEach方法的默认超时
     junit.jupiter.execution.timeout.afterall.method.default     @AfterAll方法的默认超时
 
  
    此类配置参数的值必须采用以下不区分大小写的格式： [ns|μs|ms|s|m|h|d]
 
  
  使用@Timeout进行轮询测试
 
  
    通过为轮询的异步测试配置超时，可以确保测试不会无限期执行。
 
  
      @Test
      @Timeout(5) // Poll at most 5 seconds
      void pollUntil() throws InterruptedException {
          while (asynchronousResultNotAvailable()) {
              Thread.sleep(250); // custom poll interval
          }
          // Obtain the asynchronous result and perform assertions
      }
 
  
  全局禁用@Timeout
 
  
    JUnit Jupiter支持junit.jupiter.execution.timeout.mode配置参数，用于配置何时应用超时。
     有三种模式：enabled、disabled和disabled_on_debug。默认模式enabled。
     当VM运行时的一个输入参数以-agentlib:jdwp或-Xrungdwp开头时，它被认为是在调试模式下运行的。此启发式方法由disabled_on_debug模式查询。
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(JAVA,测试,学习,junit,单元测试,教程,笔记)

        

            

                
    
                    
  • 情绪觉察日记第37天
                        露露_e800

                        
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 铭刻于星（四十二）
                        随风至

                        
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    
                    
    • 
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • 10月|愿你的青春不负梦想-读书笔记-01
                        Tracy的小书斋

                        
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    
                    
    • 
                    
  • 《投行人生》读书笔记
                        小蘑菇的树洞

                        
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）
                        研学随笔
arcgis经验分享
                        
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • 回溯 Leetcode 332 重新安排行程
                        mmaerd
Leetcode刷题学习记录leetcode算法职场和发展
                        
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
    
                    
    • 
                    
  • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    
                    
    • 
                    
  • git常用命令笔记
                        咩酱-小羊
git笔记
                        
    ###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
    
                    
    • 
                    
  • 2019-12-22-22:30
                        涓涓1016

                        
    今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
    
                    
    • 
                    
  • 第四天旅游线路预览——从换乘中心到喀纳斯湖
                        陟彼高冈yu
基于Googleearthstudio的旅游规划和预览旅游
                        
    第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
    
                    
    • 
                    
  • Python教程：一文了解使用Python处理XPath
                        旦莫
Python进阶python开发语言
                        
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
    
                    
    • 
                    
  • linux中sdl的使用教程,sdl使用入门
                        Melissa Corvinus
linux中sdl的使用教程
                        
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
    
                    
    • 
                    
  • 将cmd中命令输出保存为txt文本文件
                        落难Coder
Windowscmdwindow
                        
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
    
                    
    • 
                    
  • PHP环境搭建详细教程
                        好看资源平台
前端php
                        
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
    
                    
    • 
                    
  • 509. 斐波那契数(每日一题)
                        lzyprime

                        
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
    
                    
    • 
                    
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）
                        编程经验分享
开发工具服务器sshlinux
                        
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
    
                    
    • 
                    
  • 拥有断舍离的心态，过精简生活--《断舍离》读书笔记
                        爱吃丸子的小樱桃

                        
    不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
    
                    
    • 
                    
  • 四章-32-点要素的聚合
                        彩云飘过

                        
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 高端密码学院笔记285
                        柚子_b4b4

                        
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
    
                    
    • 
                    
  • 398顺境，逆境
                        戴骁勇

                        
    2018.11.27周二雾霾最近儿子进入了一段顺境期，今天表现尤其不错。今天的数学测试成绩喜人，没有出现以往的计算错误，整个卷面书写工整，附加题也在规定时间内完成且做对。为迎接体育测试的锻炼有了质的飞跃。坐位体前屈成绩突飞猛进，估测成绩能达到12cm，这和上次测试的零分来比，简直是逆袭。儿子还在不断锻炼和提升，唯恐到时候掉链子。跑步姿势在我的调教下，逐渐正规起来，速度随之也有了提升。今晚测试的50
    
                    
    • 
                    
  • GitHub上克隆项目
                        bigbig猩猩
github
                        
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
    
                    
    • 
                                
  • 多线程编程之理财
                                    周凡杨
java多线程生产者消费者理财
                                    
          现实生活中，我们一边工作，一边消费，正常情况下会把多余的钱存起来，比如存到余额宝，还可以多挣点钱，现在就有这个情况：我每月可以发工资20000万元 （暂定每月的1号），每月消费5000（租房+生活费）元（暂定每月的1号），其中租金是大头占90%，交房租的方式可以选择（一月一交，两月一交、三月一交），理财：1万元存余额宝一天可以赚1元钱，
    
                                
    • 
                                
  • [Zookeeper学习笔记之三]Zookeeper会话超时机制
                                    bit1129
zookeeper
                                    
    首先，会话超时是由Zookeeper服务端通知客户端会话已经超时，客户端不能自行决定会话已经超时，不过客户端可以通过调用Zookeeper.close()主动的发起会话结束请求，如下的代码输出内容 
Created /zoo-739160015 
CONNECTEDCONNECTED 
.............CONNECTEDCONNECTED 
CONNECTEDCLOSEDCLOSED 

    
                                
    • 
                                
  • SecureCRT快捷键
                                    daizj
secureCRT快捷键
                                    
    ctrl + a : 移动光标到行首ctrl + e ：移动光标到行尾crtl + b: 光标前移1个字符crtl + f: 光标后移1个字符crtl + h : 删除光标之前的一个字符ctrl + d ：删除光标之后的一个字符crtl + k ：删除光标到行尾所有字符crtl + u : 删除光标至行首所有字符crtl + w:  删除光标至行首
    
                                
    • 
                                
  • Java 子类与父类这间的转换
                                    周凡杨
java 父类与子类的转换
                                    
        最近同事调的一个服务报错，查看后是日期之间转换出的问题。代码里是把 java.sql.Date 类型的对象 强制转换为 java.sql.Timestamp 类型的对象。报java.lang.ClassCastException。 
  
    代码： 
            
    
                                
    • 
                                
  • 可视化swing界面编辑
                                    朱辉辉33
eclipseswing
                                    
          今天发现了一个WindowBuilder插件，功能好强大，啊哈哈，从此告别手动编辑swing界面代码，直接像VB那样编辑界面，代码会自动生成。 
      首先在Eclipse中点击help，选择Install New Software,然后在Work with中输入WindowBui
    
                                
    • 
                                
  • web报表工具FineReport常用函数的用法总结（文本函数）
                                    老A不折腾
finereportweb报表工具报表软件java报表
                                    
    文本函数 
CHAR 
CHAR(number):根据指定数字返回对应的字符。CHAR函数可将计算机其他类型的数字代码转换为字符。 
Number:用于指定字符的数字，介于1Number:用于指定字符的数字，介于165535之间（包括1和65535）。 
示例: 
CHAR(88)等于“X”。 
CHAR(45)等于“-”。 
  
CODE 
CODE(text):计算文本串中第一个字
    
                                
    • 
                                
  • mysql安装出错
                                    林鹤霄
mysql安装
                                    
    [root@localhost ~]# rpm -ivh MySQL-server-5.5.24-1.linux2.6.x86_64.rpm Preparing...                #####################
    
                                
    • 
                                
  • linux下编译libuv
                                    aigo
libuv
                                    
    下载最新版本的libuv源码，解压后执行： 
./autogen.sh 
  
这时会提醒找不到automake命令，通过一下命令执行安装（redhat系用yum，Debian系用apt-get）： 
# yum -y install automake 
# yum -y install libtool 
  
  
如果提示错误：make: *** No targe
    
                                
    • 
                                
  • 中国行政区数据及三级联动菜单
                                    alxw4616

                                    
    近期做项目需要三级联动菜单,上网查了半天竟然没有发现一个能直接用的! 
呵呵,都要自己填数据....我了个去这东西麻烦就麻烦的数据上. 
哎,自己没办法动手写吧. 
现将这些数据共享出了,以方便大家.嗯,代码也可以直接使用 
  文件说明 
 
 lib\area.sql -- 县及县以上行政区划分代码（截止2013年8月31日)来源：国家统计局 发布时间：2014-01-17 15:0
    
                                
    • 
                                
  • 哈夫曼加密文件
                                    百合不是茶
哈夫曼压缩哈夫曼加密二叉树
                                    
     在上一篇介绍过哈夫曼编码的基础知识,下面就直接介绍使用哈夫曼编码怎么来做文件加密或者压缩与解压的软件,对于新手来是有点难度的,主要还是要理清楚步骤; 
  
加密步骤: 
 1,统计文件中字节出现的次数,作为权值 
  
2,创建节点和哈夫曼树 
  
3,得到每个子节点01串 
  
4,使用哈夫曼编码表示每个字节 
  

    
                                
    • 
                                
  • JDK1.5 Cyclicbarrier实例
                                    bijian1013
javathreadjava多线程Cyclicbarrier
                                    
    CyclicBarrier类 
一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环的 barrier。 
CyclicBarrier支持一个可选的 Runnable 命令，
    
                                
    • 
                                
  • 九项重要的职业规划
                                    bijian1013
工作学习
                                    
    一. 学习的步伐不停止        古人说，活到老，学到老。终身学习应该是您的座右铭。        世界在不断变化，每个人都在寻找各自的事业途径。        您只有保证了足够的技能储
    
                                
    • 
                                
  • 【Java范型四】范型方法
                                    bit1129
java
                                    
    范型参数不仅仅可以用于类型的声明上，例如 
  
package com.tom.lang.generics;

import java.util.List;

public class Generics<T> {
    private T value;
    public Generics(T  value) {
        this.value = 
    
                                
    • 
                                
  • 【Hadoop十三】HDFS Java API基本操作
                                    bit1129
hadoop
                                    
      
package com.examples.hadoop;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoo
    
                                
    • 
                                
  • ua实现split字符串分隔
                                    ronin47
lua split
                                    
    LUA并不象其它许多"大而全"的语言那样，包括很多功能，比如网络通讯、图形界面等。但是LUA可以很容易地被扩展：由宿主语言(通常是C或 C++)提供这些功能，LUA可以使用它们，就像是本来就内置的功能一样。LUA只包括一个精简的核心和最基本的库。这使得LUA体积小、启动速度快，从 而适合嵌入在别的程序里。因此在lua中并没有其他语言那样多的系统函数。习惯了其他语言的字符串分割函
    
                                
    • 
                                
  • java-从先序遍历和中序遍历重建二叉树
                                    bylijinnan
java
                                    
    

public class BuildTreePreOrderInOrder {

	/**
	 * Build Binary Tree from PreOrder and InOrder
	 *  _______7______
       /              \
    __10__          ___2
   /      \        /
   4
    
                                
    • 
                                
  • openfire开发指南《连接和登陆》
                                    开窍的石头
openfire开发指南smack
                                    
    第一步 
    官网下载smack.jar包 
    下载地址：http://www.igniterealtime.org/downloads/index.jsp#smack 
第二步 
    把smack里边的jar导入你新建的java项目中 
 
开始编写smack连接openfire代码 
 
p
    
                                
    • 
                                
  • [移动通讯]手机后盖应该按需要能够随时开启
                                    comsci
移动
                                    
        看到新的手机，很多由金属材质做的外壳，内存和闪存容量越来越大，CPU速度越来越快，对于这些改进，我们非常高兴，也非常欢迎 
 
     但是，对于手机的新设计，有几点我们也要注意 
 
     第一：手机的后盖应该能够被用户自行取下来，手机的电池的可更换性应该是必须保留的设计,
    
                                
    • 
                                
  • 20款国外知名的php开源cms系统
                                    cuiyadll
cms
                                    
    内容管理系统，简称CMS，是一种简易的发布和管理新闻的程序。用户可以在后端管理系统中发布，编辑和删除文章，即使您不需要懂得HTML和其他脚本语言，这就是CMS的优点。 
在这里我决定介绍20款目前国外市面上最流行的开源的PHP内容管理系统，以便没有PHP知识的读者也可以通过国外内容管理系统建立自己的网站。 
1. Wordpress 
WordPress的是一个功能强大且易于使用的内容管
    
                                
    • 
                                
  • Java生成全局唯一标识符
                                    darrenzhu
javauuiduniqueidentifierid
                                    
    How to generate a globally unique identifier in Java 
 
 
 
http://stackoverflow.com/questions/21536572/generate-unique-id-in-java-to-label-groups-of-related-entries-in-a-log 
 
 
http://stackoverflow
    
                                
    • 
                                
  • php安装模块检测是否已安装过, 使用的SQL语句
                                    dcj3sjt126com
sql
                                    
           
SHOW [FULL] TABLES [FROM db_name] [LIKE 'pattern'] 
SHOW TABLES列举了给定数据库中的非TEMPORARY表。您也可以使用mysqlshow db_name命令得到此清单。 
本命令也列举数据库中的其它视图。支持FULL修改符，这样SHOW FULL TABLES就可以显示第二个输出列。对于一个表，第二列的值为BASE T
    
                                
    • 
                                
  • 5天学会一种 web 开发框架
                                    dcj3sjt126com
Web框架framework
                                    
    web framework层出不穷，特别是ruby/python,各有10+个,php/java也是一大堆 根据我自己的经验写了一个to do list,按照这个清单，一条一条的学习，事半功倍，很快就能掌握 一共25条，即便很磨蹭，2小时也能搞定一条，25*2=50。只需要50小时就能掌握任意一种web框架 
各类web框架大同小异:现代web开发框架的6大元素，把握主线，就不会迷路 
建议把本文
    
                                
    • 
                                
  • Gson使用三(Map集合的处理,一对多处理)
                                    eksliang
jsongsonGson mapGson 集合处理
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2175532 一、概述 
       Map保存的是键值对的形式，Json的格式也是键值对的，所以正常情况下，map跟json之间的转换应当是理所当然的事情。 二、Map参考实例 
package com.ickes.json;

import java.lang.refl
    
                                
    • 
                                
  • cordova实现“再点击一次退出”效果
                                    gundumw100
android
                                    
    基本的写法如下： 
 


document.addEventListener("deviceready", onDeviceReady, false);
			
function onDeviceReady() {
	//navigator.splashscreen.hide();
        document.addEventListener("b
    
                                
    • 
                                
  • openldap configuration leaning note
                                    iwindyforest
configuration
                                    
    hostname // to display the computer name 
hostname <changed name> // to change 
go to: /etc/sysconfig/network, add/modify HOSTNAME=NEWNAME to change permenately 
dont forget to change /etc/hosts
    
                                
    • 
                                
  • Nullability and Objective-C
                                    啸笑天
Objective-C
                                    
    https://developer.apple.com/swift/blog/?id=25 
  
http://www.cocoachina.com/ios/20150601/11989.html 
  
http://blog.csdn.net/zhangao0086/article/details/44409913 
  
http://blog.sunnyxx
    
                                
    • 
                                
  • jsp中实现参数隐藏的两种方法
                                    macroli
JavaScriptjsp
                                    
    在一个JSP页面有一个链接，//确定是一个链接?点击弹出一个页面，需要传给这个页面一些参数。//正常的方法是设置弹出页面的src="***.do?p1=aaa&p2=bbb&p3=ccc"//确定目标URL是Action来处理?但是这样会在页面上看到传过来的参数，可能会不安全。要求实现src="***.do"，参数通过其他方法传！//////
    
                                
    • 
                                
  • Bootstrap A标签关闭modal并打开新的链接解决方案
                                    qiaolevip
每天进步一点点学习永无止境bootstrap纵观千象
                                    
    Bootstrap里面的js modal控件使用起来很方便，关闭也很简单。只需添加标签 data-dismiss="modal" 即可。 
可是偏偏有时候需要a标签既要关闭modal，有要打开新的链接，尝试多种方法未果。只好使用原始js来控制。 
  
<a href="#/group-buy" class="btn bt
    
                                
    • 
                                
  • 二维数组在Java和C中的区别
                                    流淚的芥末
javac二维数组数组
                                    
    Java代码： 
  
public class test03 {
	public static void main(String[] args) {
		int[][] a = {{1},{2,3},{4,5,6}};
		System.out.println(a[0][1]);
	}
} 
 运行结果： 
Exception in thread "mai
    
                                
    • 
                                
  • systemctl命令用法
                                    wmlJava
linuxsystemctl
                                    
    对比表，以 apache / httpd 为例   任务 旧指令 新指令   使某服务自动启动 chkconfig --level 3 httpd on systemctl enable httpd.service   使某服务不自动启动 chkconfig --level 3 httpd off systemctl disable httpd.service   检查服务状态 service h
    
                                
    •