断言

JUnit Jupiter提供了许多JUnit4已有的断言方法，并增加了一些适合与Java 8 lambda一起使用的断言方法。所有JUnit Jupiter断言都是org.junit.jupiter.Assertions类中的静态方法。

  1. import static java.time.Duration.ofMillis;
  2. import static java.time.Duration.ofMinutes;
  3. import static org.junit.jupiter.api.Assertions.assertAll;
  4. import static org.junit.jupiter.api.Assertions.assertEquals;
  5. import static org.junit.jupiter.api.Assertions.assertNotNull;
  6. import static org.junit.jupiter.api.Assertions.assertThrows;
  7. import static org.junit.jupiter.api.Assertions.assertTimeout;
  8. import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively;
  9. import static org.junit.jupiter.api.Assertions.assertTrue;
  11. import org.junit.jupiter.api.Test;
  13. class AssertionsDemo {
  15.     @Test
  16.     void standardAssertions() {
  17.         assertEquals(2, 2);
  18.         assertEquals(4, 4, "The optional assertion message is now the last parameter.");
  19.         assertTrue(2 == 2, () -> "Assertion messages can be lazily evaluated -- "
  20.                 + "to avoid constructing complex messages unnecessarily.");
  21.     }
  23.     @Test
  24.     void groupedAssertions() {
  25.         // In a grouped assertion all assertions are executed, and any
  26.         // failures will be reported together.
  27.         assertAll("person",
  28.             () -> assertEquals("John", person.getFirstName()),
  29.             () -> assertEquals("Doe", person.getLastName())
  30.         );
  31.     }
  33.     @Test
  34.     void dependentAssertions() {
  35.         // Within a code block, if an assertion fails the
  36.         // subsequent code in the same block will be skipped.
  37.         assertAll("properties",
  38.             () -> {
  39.                 String firstName = person.getFirstName();
  40.                 assertNotNull(firstName);
  42.                 // Executed only if the previous assertion is valid.
  43.                 assertAll("first name",
  44.                     () -> assertTrue(firstName.startsWith("J")),
  45.                     () -> assertTrue(firstName.endsWith("n"))
  46.                 );
  47.             },
  48.             () -> {
  49.                 // Grouped assertion, so processed independently
  50.                 // of results of first name assertions.
  51.                 String lastName = person.getLastName();
  52.                 assertNotNull(lastName);
  54.                 // Executed only if the previous assertion is valid.
  55.                 assertAll("last name",
  56.                     () -> assertTrue(lastName.startsWith("D")),
  57.                     () -> assertTrue(lastName.endsWith("e"))
  58.                 );
  59.             }
  60.         );
  61.     }
  63.     @Test
  64.     void exceptionTesting() {
  65.         Throwable exception = assertThrows(IllegalArgumentException.class, () -> {
  66.             throw new IllegalArgumentException("a message");
  67.         });
  68.         assertEquals("a message", exception.getMessage());
  69.     }
  71.     @Test
  72.     void timeoutNotExceeded() {
  73.         // The following assertion succeeds.
  74.         assertTimeout(ofMinutes(2), () -> {
  75.             // Perform task that takes less than 2 minutes.
  76.         });
  77.     }
  79.     @Test
  80.     void timeoutNotExceededWithResult() {
  81.         // The following assertion succeeds, and returns the supplied object.
  82.         String actualResult = assertTimeout(ofMinutes(2), () -> {
  83.             return "a result";
  84.         });
  85.         assertEquals("a result", actualResult);
  86.     }
  88.     @Test
  89.     void timeoutNotExceededWithMethod() {
  90.         // The following assertion invokes a method reference and returns an object.
  91.         String actualGreeting = assertTimeout(ofMinutes(2), AssertionsDemo::greeting);
  92.         assertEquals("hello world!", actualGreeting);
  93.     }
  95.     @Test
  96.     void timeoutExceeded() {
  97.         // The following assertion fails with an error message similar to:
  98.         // execution exceeded timeout of 10 ms by 91 ms
  99.         assertTimeout(ofMillis(10), () -> {
  100.             // Simulate task that takes more than 10 ms.
  101.             Thread.sleep(100);
  102.         });
  103.     }
  105.     @Test
  106.     void timeoutExceededWithPreemptiveTermination() {
  107.         // The following assertion fails with an error message similar to:
  108.         // execution timed out after 10 ms
  109.         assertTimeoutPreemptively(ofMillis(10), () -> {
  110.             // Simulate task that takes more than 10 ms.
  111.             Thread.sleep(100);
  112.         });
  113.     }
  115.     private static String greeting() {
  116.         return "hello world!";
  117.     }
  119. }

第三方断言类库

虽然JUnit Jupiter提供的断言功能足以满足许多测试场景的需要，但是有时需要更强大和附加功能，例如匹配器。在这种情况下，JUnit小组推荐使用AssertJ，Hamcrest，Truth等第三方断言库。开发人员可以自由使用他们选择的断言库。

例如，匹配器和fluent API的组合可以用来使断言更具描述性和可读性。但是，JUnit Jupiter的org.junit.jupiter.Assertions类没有提供类似于JUnit 4的org.junit.Assert类的assertThat()方法，以接受Hamcrest Matcher。相反，鼓励开发人员使用由第三方断言库提供的匹配器的内置支持。

以下示例演示如何在JUnit Jupiter测试中使用来自Hamcrest的assertThat()支持。 只要Hamcrest库已经添加到classpath中，就可以静态地导入诸如assertThat()，is()和equalTo()之类的方法，然后像下面的assertWithHamcrestMatcher()方法那样在测试中使用它们。

  1. import static org.hamcrest.CoreMatchers.equalTo;
  2. import static org.hamcrest.CoreMatchers.is;
  3. import static org.hamcrest.MatcherAssert.assertThat;
  5. import org.junit.jupiter.api.Test;
  7. class HamcrestAssertionDemo {
  9.     @Test
  10.     void assertWithHamcrestMatcher() {
  11.         assertThat(2 + 1, is(equalTo(3)));
  12.     }
  14. }

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