Complete list of assertions, organized by parameter type.

All of these have variants that include a trailing message argument,
which can be provided as a direct string-value (String), 
or a function that returns a string (Supplier<String>).

-----

// should-be-true-condition
assertTrue(boolean);
assertTrue(boolean, String);
assertTrue(boolean, Supplier<String>);
assertTrue(BooleanSupplier);
assertTrue(BooleanSupplier, String);
assertTrue(BooleanSupplier, Supplier<String>);

// should-be-false-condition
assertFalse(boolean);
assertFalse(boolean, String);
assertFalse(boolean, Supplier<String>);
assertFalse(BooleanSupplier);
assertFalse(BooleanSupplier, String);
assertFalse(BooleanSupplier, Supplier<String>);

-----

// object-that-should-be-null
assertNull(Object);
assertNull(Object, String);
assertNull(Object, Supplier<String>);

// object-that-should-not-be-null
assertNotNull(Object);
assertNotNull(Object, String);
assertNotNull(Object, Supplier<String>);

-----

// two-references-to-the-same-instance
assertSame(Object, Object);
assertSame(Object, Object, String);
assertSame(Object, Object, Supplier<String>);

// references-to-different-instances
assertNotSame(Object, Object);
assertNotSame(Object, Object, String);
assertNotSame(Object, Object, Supplier<String>);

-----

// expected, actual
assertEquals(byte, byte);
assertEquals(byte, byte, String);
assertEquals(byte, byte, Supplier<String>);

// expected, actual
assertEquals(short, short);
assertEquals(short, short, String);
assertEquals(short, short, Supplier<String>);

// expected, actual
assertEquals(int, int);
assertEquals(int, int, String);
assertEquals(int, int, Supplier<String>);

// expected, actual
assertEquals(long, long);
assertEquals(long, long, String);
assertEquals(long, long, Supplier<String>);

// expected, actual
assertEquals(char, char);
assertEquals(char, char, String);
assertEquals(char, char, Supplier<String>);

// expected, actual
assertEquals(float, float);
assertEquals(float, float, String);
assertEquals(float, float, Supplier<String>);

// expected, actual, delta
assertEquals(float, float, float);
assertEquals(float, float, float, String);
assertEquals(float, float, float, Supplier<String>);

// expected, actual
assertEquals(double, double);
assertEquals(double, double, String);
assertEquals(double, double, Supplier<String>);

// expected, actual, delta
assertEquals(double, double, double);
assertEquals(double, double, double, String);
assertEquals(double, double, double, Supplier<String>);


// expected, actual
assertEquals(Object, Object);
assertEquals(Object, Object, String);
assertEquals(Object, Object, Supplier<String>);


// unequal, objects
assertNotEquals(Object, Object);
assertNotEquals(Object, Object, String);
assertNotEquals(Object, Object, Supplier<String>);

-----

// expecteds, actuals
assertArrayEquals(boolean[], boolean[]);
assertArrayEquals(boolean[], boolean[], String);
assertArrayEquals(boolean[], boolean[], Supplier<String>);

// expecteds, actuals
assertArrayEquals(byte[], byte[]);
assertArrayEquals(byte[], byte[], String);
assertArrayEquals(byte[], byte[], Supplier<String>);

// expecteds, actuals
assertArrayEquals(short[], short[]);
assertArrayEquals(short[], short[], String);
assertArrayEquals(short[], short[], Supplier<String>);

// expecteds, actuals
assertArrayEquals(int[], int[]);
assertArrayEquals(int[], int[], String);
assertArrayEquals(int[], int[], Supplier<String>);

// expecteds, actuals
assertArrayEquals(long[], long[]);
assertArrayEquals(long[], long[], String);
assertArrayEquals(long[], long[], Supplier<String>);

// expecteds, actuals
assertArrayEquals(char[], char[]);
assertArrayEquals(char[], char[], String);
assertArrayEquals(char[], char[], Supplier<String>);

// expecteds, actuals
assertArrayEquals(float[], float[]);
assertArrayEquals(float[], float[], String);
assertArrayEquals(float[], float[], Supplier<String>);

// expecteds, actuals, delta
assertArrayEquals(float[], float[], float);
assertArrayEquals(float[], float[], float, String);
assertArrayEquals(float[], float[], float, Supplier<String>);

// expecteds, actuals
assertArrayEquals(double[], double[]);
assertArrayEquals(double[], double[], String);
assertArrayEquals(double[], double[], Supplier<String>);

// expecteds, actuals, delta
assertArrayEquals(double[], double[], double);
assertArrayEquals(double[], double[], double, String);
assertArrayEquals(double[], double[], double, Supplier<String>);


// expecteds, actuals
assertArrayEquals(Object[], Object[]);
assertArrayEquals(Object[], Object[], String);
assertArrayEquals(Object[], Object[], Supplier<String>);


// expecteds, actuals
assertIterableEquals(Iterable<?>, Iterable<?>);
assertIterableEquals(Iterable<?>, Iterable<?>, String);
assertIterableEquals(Iterable<?>, Iterable<?>, Supplier<String>);

-----

// expected-exception, action
assertThrows(Class<T>, Executable);
assertThrows(Class<T>, Executable, String);
assertThrows(Class<T>, Executable, Supplier<String>);

-----

// must-finish-within, action   [wait-for-action-then-fail]
assertTimeout(Duration, Executable);
assertTimeout(Duration, Executable, String);
assertTimeout(Duration, Executable, Supplier<String>);

// must-finish-within, action-that-returns-something   [wait-for-action-then-fail]
assertTimeout(Duration, ThrowingSupplier<T>);
assertTimeout(Duration, ThrowingSupplier<T>, String);
assertTimeout(Duration, ThrowingSupplier<T>, Supplier<String>);


// must-finish-within, action   [fail-when-times-up]
assertTimeoutPreemptively(Duration, Executable);
assertTimeoutPreemptively(Duration, Executable, String);
assertTimeoutPreemptively(Duration, Executable, Supplier<String>);

// must-finish-within, action-that-returns-something   [fail-when-times-up]
assertTimeoutPreemptively(Duration, ThrowingSupplier<T>);
assertTimeoutPreemptively(Duration, ThrowingSupplier<T>, String);
assertTimeoutPreemptively(Duration, ThrowingSupplier<T>, Supplier<String>);

-----

// group-label, action(s)
assertAll(Executable...)
assertAll(String, Executable...)

assertAll(Collection<Executable>)
assertAll(String, Collection<Executable>)

assertAll(Stream<Executable>)
assertAll(String, Stream<Executable>)

-----