JUnit 4とJUnit 5のアサーション

@Test
public void whenAssertingEquality__thenEqual() {
    String expected = "Baeldung";
    String actual = "Baeldung";

    assertEquals(expected, actual);
}

assertEquals("failure - strings are not equal", expected, actual);

@Test
public void whenAssertingArraysEquality__thenEqual() {
    char[]expected = {'J','u','n','i','t'};
    char[]actual = "Junit".toCharArray();

    assertArrayEquals(expected, actual);
}

@Test
public void givenNullArrays__whenAssertingArraysEquality__thenEqual() {
    int[]expected = null;
    int[]actual = null;

    assertArrayEquals(expected, actual);
}

@Test
public void whenAssertingNull__thenTrue() {
    Object car = null;

    assertNull("The car should be null", car);
}

@Test
public void whenAssertingNotSameObject__thenDifferent() {
    Object cat = new Object();
    Object dog = new Object();

    assertNotSame(cat, dog);
}

@Test
public void whenAssertingConditions__thenVerified() {
    assertTrue("5 is greater then 4", 5 > 4);
    assertFalse("5 is not greater then 6", 5 > 6);
}

@Test
public void whenCheckingExceptionMessage__thenEqual() {
    try {
        methodThatShouldThrowException();
        fail("Exception not thrown");
    } catch (UnsupportedOperationException e) {
        assertEquals("Operation Not Supported", e.getMessage());
    }
}

@Test
public void testAssertThatHasItems() {
    assertThat(
      Arrays.asList("Java", "Kotlin", "Scala"),
      hasItems("Java", "Kotlin"));
}

@Test
public void whenAssertingArraysEquality__thenEqual() {
    char[]expected = { 'J', 'u', 'p', 'i', 't', 'e', 'r' };
    char[]actual = "Jupiter".toCharArray();

    assertArrayEquals(expected, actual, "Arrays should be equal");
}

@Test
public void whenAssertingEquality__thenEqual() {
    float square = 2 **  2;
    float rectangle = 2 **  2;

    assertEquals(square, rectangle);
}

@Test
public void whenAssertingEqualityWithDelta__thenEqual() {
    float square = 2 **  2;
    float rectangle = 3 **  2;
    float delta = 2;

    assertEquals(square, rectangle, delta);
}

@Test
public void whenAssertingConditions__thenVerified() {
    assertTrue(5 > 4, "5 is greater the 4");
    assertTrue(null == null, "null is equal to null");
}

@Test
public void givenBooleanSupplier__whenAssertingCondition__thenVerified() {
    BooleanSupplier condition = () -> 5 > 6;

    assertFalse(condition, "5 is not greater then 6");
}

@Test
public void whenAssertingNotNull__thenTrue() {
    Object dog = new Object();

    assertNotNull(dog, () -> "The dog should not be null");
}

@Test
public void whenAssertingNull__thenTrue() {
    Object cat = null;

    assertNull(cat, () -> "The cat should be null");
}

@Test
public void whenAssertingSameObject__thenSuccessfull() {
    String language = "Java";
    Optional<String> optional = Optional.of(language);

    assertSame(language, optional.get());
}

@Test
public void whenFailingATest__thenFailed() {
   //Test not completed
    fail("FAIL - test not completed");
}

@Test
public void givenMultipleAssertion__whenAssertingAll__thenOK() {
    assertAll(
      "heading",
      () -> assertEquals(4, 2 **  2, "4 is 2 times 2"),
      () -> assertEquals("java", "JAVA".toLowerCase()),
      () -> assertEquals(null, null, "null is equal to null")
    );
}

@Test
public void givenTwoLists__whenAssertingIterables__thenEquals() {
    Iterable<String> al = new ArrayList<>(asList("Java", "Junit", "Test"));
    Iterable<String> ll = new LinkedList<>(asList("Java", "Junit", "Test"));

    assertIterableEquals(al, ll);
}

@Test
public void whenAssertingEqualityListOfStrings__thenEqual() {
    List<String> expected = asList("Java", "\\d+", "JUnit");
    List<String> actual = asList("Java", "11", "JUnit");

    assertLinesMatch(expected, actual);
}

@Test
public void whenAssertingEquality__thenNotEqual() {
    Integer value = 5;//result of an algorithm

    assertNotEquals(0, value, "The result cannot be 0");
}

@Test
void whenAssertingException__thenThrown() {
    Throwable exception = assertThrows(
      IllegalArgumentException.class,
      () -> {
          throw new IllegalArgumentException("Exception message");
      }
    );
    assertEquals("Exception message", exception.getMessage());
}

@Test
public void whenAssertingTimeout__thenNotExceeded() {
    assertTimeout(
      ofSeconds(2),
      () -> {
       //code that requires less then 2 minutes to execute
        Thread.sleep(1000);
      }
    );
}