Class Assertions

java.lang.Object

org.junit.jupiter.api.Assertions

@API(status=STABLE,
     since="5.0")
public class Assertions
extends Object

Assertions is a collection of utility methods that support asserting conditions in tests.

Unless otherwise noted, a failed assertion will throw an AssertionFailedError or a subclass thereof.

Object Equality

Assertion methods comparing two objects for equality, such as the assertEquals(expected, actual) and assertNotEquals(unexpected, actual) variants, are only intended to test equality for an (un-)expected value and an actual value. They are not designed for testing whether a class correctly implements Object.equals(Object). For example, assertEquals() might immediately return true when provided the same object for the expected and actual values, without calling equals(Object) at all. Tests that aim to verify the equals(Object) implementation should instead be written to explicitly verify the Object.equals(Object) contract by using assertTrue() or assertFalse() — for example, assertTrue(expected.equals(actual)), assertTrue(actual.equals(expected)), assertFalse(expected.equals(null)), etc.

Kotlin Support

Additional Kotlin assertions can be found as top-level functions in the org.junit.jupiter.api package.

Preemptive Timeouts

The various assertTimeoutPreemptively() methods in this class execute the provided callback (executable or supplier) in a different thread than that of the calling code. If the timeout is exceeded, an attempt will be made to preemptively abort execution of the callback by interrupting the callback's thread. If the callback's thread does not return when interrupted, the thread will continue to run in the background after the assertTimeoutPreemptively() method has returned.

Furthermore, the behavior of assertTimeoutPreemptively() methods can lead to undesirable side effects if the code that is executed within the callback relies on ThreadLocal storage. One common example of this is the transactional testing support in the Spring Framework. Specifically, Spring's testing support binds transaction state to the current thread (via a ThreadLocal) before a test method is invoked. Consequently, if a callback provided to assertTimeoutPreemptively() invokes Spring-managed components that participate in transactions, any actions taken by those components will not be rolled back with the test-managed transaction. On the contrary, such actions will be committed to the persistent store (e.g., relational database) even though the test-managed transaction is rolled back. Similar side effects may be encountered with other frameworks that rely on ThreadLocal storage.

Extensibility

Although it is technically possible to extend this class, extension is strongly discouraged. The JUnit Team highly recommends that the methods defined in this class be used via static imports.

Since:

5.0

See Also:

• AssertionFailedError
• Assumptions

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	Assertions()	Protected constructor allowing subclassing but not direct instantiation.

Method Summary

Modifier and Type	Method	Description
static void	assertAll(@Nullable String heading, Collection<Executable> executables)	Assert that all supplied executables do not throw exceptions.
static void	assertAll(@Nullable String heading, Stream<Executable> executables)	Assert that all supplied executables do not throw exceptions.
static void	assertAll(@Nullable String heading, Executable... executables)	Assert that all supplied executables do not throw exceptions.
static void	assertAll(Collection<Executable> executables)	Assert that all supplied executables do not throw exceptions.
static void	assertAll(Stream<Executable> executables)	Assert that all supplied executables do not throw exceptions.
static void	assertAll(Executable... executables)	Assert that all supplied executables do not throw exceptions.
static void	assertArrayEquals(boolean @Nullable [] expected, boolean @Nullable [] actual)	Assert that expected and actual boolean arrays are equal.
static void	assertArrayEquals(boolean @Nullable [] expected, boolean @Nullable [] actual, @Nullable String message)	Assert that expected and actual boolean arrays are equal.
static void	assertArrayEquals(boolean @Nullable [] expected, boolean @Nullable [] actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual boolean arrays are equal.
static void	assertArrayEquals(byte @Nullable [] expected, byte @Nullable [] actual)	Assert that expected and actual byte arrays are equal.
static void	assertArrayEquals(byte @Nullable [] expected, byte @Nullable [] actual, @Nullable String message)	Assert that expected and actual byte arrays are equal.
static void	assertArrayEquals(byte @Nullable [] expected, byte @Nullable [] actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual byte arrays are equal.
static void	assertArrayEquals(char @Nullable [] expected, char @Nullable [] actual)	Assert that expected and actual char arrays are equal.
static void	assertArrayEquals(char @Nullable [] expected, char @Nullable [] actual, @Nullable String message)	Assert that expected and actual char arrays are equal.
static void	assertArrayEquals(char @Nullable [] expected, char @Nullable [] actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual char arrays are equal.
static void	assertArrayEquals(double @Nullable [] expected, double @Nullable [] actual)	Assert that expected and actual double arrays are equal.
static void	assertArrayEquals(double @Nullable [] expected, double @Nullable [] actual, double delta)	Assert that expected and actual double arrays are equal within the given non-negative delta.
static void	assertArrayEquals(double @Nullable [] expected, double @Nullable [] actual, double delta, @Nullable String message)	Assert that expected and actual double arrays are equal within the given non-negative delta.
static void	assertArrayEquals(double @Nullable [] expected, double @Nullable [] actual, double delta, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual double arrays are equal within the given non-negative delta.
static void	assertArrayEquals(double @Nullable [] expected, double @Nullable [] actual, @Nullable String message)	Assert that expected and actual double arrays are equal.
static void	assertArrayEquals(double @Nullable [] expected, double @Nullable [] actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual double arrays are equal.
static void	assertArrayEquals(float @Nullable [] expected, float @Nullable [] actual)	Assert that expected and actual float arrays are equal.
static void	assertArrayEquals(float @Nullable [] expected, float @Nullable [] actual, float delta)	Assert that expected and actual float arrays are equal within the given non-negative delta.
static void	assertArrayEquals(float @Nullable [] expected, float @Nullable [] actual, float delta, @Nullable String message)	Assert that expected and actual float arrays are equal within the given non-negative delta.
static void	assertArrayEquals(float @Nullable [] expected, float @Nullable [] actual, float delta, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual float arrays are equal within the given non-negative delta.
static void	assertArrayEquals(float @Nullable [] expected, float @Nullable [] actual, @Nullable String message)	Assert that expected and actual float arrays are equal.
static void	assertArrayEquals(float @Nullable [] expected, float @Nullable [] actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual float arrays are equal.
static void	assertArrayEquals(int @Nullable [] expected, int @Nullable [] actual)	Assert that expected and actual int arrays are equal.
static void	assertArrayEquals(int @Nullable [] expected, int @Nullable [] actual, @Nullable String message)	Assert that expected and actual int arrays are equal.
static void	assertArrayEquals(int @Nullable [] expected, int @Nullable [] actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual int arrays are equal.
static void	assertArrayEquals(long @Nullable [] expected, long @Nullable [] actual)	Assert that expected and actual long arrays are equal.
static void	assertArrayEquals(long @Nullable [] expected, long @Nullable [] actual, @Nullable String message)	Assert that expected and actual long arrays are equal.
static void	assertArrayEquals(long @Nullable [] expected, long @Nullable [] actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual long arrays are equal.
static void	assertArrayEquals(short @Nullable [] expected, short @Nullable [] actual)	Assert that expected and actual short arrays are equal.
static void	assertArrayEquals(short @Nullable [] expected, short @Nullable [] actual, @Nullable String message)	Assert that expected and actual short arrays are equal.
static void	assertArrayEquals(short @Nullable [] expected, short @Nullable [] actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual short arrays are equal.
static void	assertArrayEquals(@Nullable Object @Nullable [] expected, @Nullable Object @Nullable [] actual)	Assert that expected and actual object arrays are deeply equal.
static void	assertArrayEquals(@Nullable Object @Nullable [] expected, @Nullable Object @Nullable [] actual, @Nullable String message)	Assert that expected and actual object arrays are deeply equal.
static void	assertArrayEquals(@Nullable Object @Nullable [] expected, @Nullable Object @Nullable [] actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual object arrays are deeply equal.
static void	assertDoesNotThrow(Executable executable)	Assert that execution of the supplied executable does not throw any kind of exception.
static void	assertDoesNotThrow(Executable executable, @Nullable String message)	Assert that execution of the supplied executable does not throw any kind of exception.
static void	assertDoesNotThrow(Executable executable, Supplier<@Nullable String> messageSupplier)	Assert that execution of the supplied executable does not throw any kind of exception.
static <T extends @Nullable Object> T	assertDoesNotThrow(ThrowingSupplier<T> supplier)	Assert that execution of the supplied supplier does not throw any kind of exception.
static <T extends @Nullable Object> T	assertDoesNotThrow(ThrowingSupplier<T> supplier, @Nullable String message)	Assert that execution of the supplied supplier does not throw any kind of exception.
static <T extends @Nullable Object> T	assertDoesNotThrow(ThrowingSupplier<T> supplier, Supplier<@Nullable String> messageSupplier)	Assert that execution of the supplied supplier does not throw any kind of exception.
static void	assertEquals(byte expected, byte actual)	Assert that expected and actual are equal.
static void	assertEquals(byte expected, byte actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(byte expected, byte actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(byte expected, @Nullable Byte actual)	Assert that expected and actual are equal.
static void	assertEquals(byte expected, @Nullable Byte actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(byte expected, @Nullable Byte actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(char expected, char actual)	Assert that expected and actual are equal.
static void	assertEquals(char expected, char actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(char expected, char actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(char expected, @Nullable Character actual)	Assert that expected and actual are equal.
static void	assertEquals(char expected, @Nullable Character actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(char expected, @Nullable Character actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(double expected, double actual)	Assert that expected and actual are equal.
static void	assertEquals(double expected, double actual, double delta)	Assert that expected and actual are equal within the given non-negative delta.
static void	assertEquals(double expected, double actual, double delta, @Nullable String message)	Assert that expected and actual are equal within the given non-negative delta.
static void	assertEquals(double expected, double actual, double delta, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal within the given non-negative delta.
static void	assertEquals(double expected, double actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(double expected, double actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(double expected, @Nullable Double actual)	Assert that expected and actual are equal.
static void	assertEquals(double expected, @Nullable Double actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(double expected, @Nullable Double actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(float expected, float actual)	Assert that expected and actual are equal.
static void	assertEquals(float expected, float actual, float delta)	Assert that expected and actual are equal within the given non-negative delta.
static void	assertEquals(float expected, float actual, float delta, @Nullable String message)	Assert that expected and actual are equal within the given non-negative delta.
static void	assertEquals(float expected, float actual, float delta, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal within the given non-negative delta.
static void	assertEquals(float expected, float actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(float expected, float actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(float expected, @Nullable Float actual)	Assert that expected and actual are equal.
static void	assertEquals(float expected, @Nullable Float actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(float expected, @Nullable Float actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(int expected, int actual)	Assert that expected and actual are equal.
static void	assertEquals(int expected, int actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(int expected, int actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(int expected, @Nullable Integer actual)	Assert that expected and actual are equal.
static void	assertEquals(int expected, @Nullable Integer actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(int expected, @Nullable Integer actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(long expected, long actual)	Assert that expected and actual are equal.
static void	assertEquals(long expected, long actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(long expected, long actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(long expected, @Nullable Long actual)	Assert that expected and actual are equal.
static void	assertEquals(long expected, @Nullable Long actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(long expected, @Nullable Long actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(short expected, short actual)	Assert that expected and actual are equal.
static void	assertEquals(short expected, short actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(short expected, short actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(short expected, @Nullable Short actual)	Assert that expected and actual are equal.
static void	assertEquals(short expected, @Nullable Short actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(short expected, @Nullable Short actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Byte expected, byte actual)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Byte expected, byte actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Byte expected, byte actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Byte expected, @Nullable Byte actual)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Byte expected, @Nullable Byte actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Byte expected, @Nullable Byte actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Character expected, char actual)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Character expected, char actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Character expected, char actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Character expected, @Nullable Character actual)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Character expected, @Nullable Character actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Character expected, @Nullable Character actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Double expected, double actual)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Double expected, double actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Double expected, double actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Double expected, @Nullable Double actual)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Double expected, @Nullable Double actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Double expected, @Nullable Double actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Float expected, float actual)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Float expected, float actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Float expected, float actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Float expected, @Nullable Float actual)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Float expected, @Nullable Float actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Float expected, @Nullable Float actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Integer expected, int actual)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Integer expected, int actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Integer expected, int actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Integer expected, @Nullable Integer actual)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Integer expected, @Nullable Integer actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Integer expected, @Nullable Integer actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Long expected, long actual)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Long expected, long actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Long expected, long actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Long expected, @Nullable Long actual)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Long expected, @Nullable Long actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Long expected, @Nullable Long actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Object expected, @Nullable Object actual)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Object expected, @Nullable Object actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Object expected, @Nullable Object actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Short expected, short actual)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Short expected, short actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Short expected, short actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Short expected, @Nullable Short actual)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Short expected, @Nullable Short actual, @Nullable String message)	Assert that expected and actual are equal.
static void	assertEquals(@Nullable Short expected, @Nullable Short actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual are equal.
static void	assertFalse(boolean condition)	Assert that the supplied condition is false.
static void	assertFalse(boolean condition, @Nullable String message)	Assert that the supplied condition is false.
static void	assertFalse(boolean condition, Supplier<@Nullable String> messageSupplier)	Assert that the supplied condition is false.
static void	assertFalse(BooleanSupplier booleanSupplier)	Assert that the boolean condition supplied by booleanSupplier is false.
static void	assertFalse(BooleanSupplier booleanSupplier, @Nullable String message)	Assert that the boolean condition supplied by booleanSupplier is false.
static void	assertFalse(BooleanSupplier booleanSupplier, Supplier<@Nullable String> messageSupplier)	Assert that the boolean condition supplied by booleanSupplier is false.
static <T> T	assertInstanceOf(Class<T> expectedType, @Nullable Object actualValue)	Assert that the supplied actualValue is an instance of the expectedType.
static <T> T	assertInstanceOf(Class<T> expectedType, @Nullable Object actualValue, @Nullable String message)	Assert that the supplied actualValue is an instance of the expectedType.
static <T> T	assertInstanceOf(Class<T> expectedType, @Nullable Object actualValue, Supplier<@Nullable String> messageSupplier)	Assert that the supplied actualValue is an instance of the expectedType.
static void	assertIterableEquals(@Nullable Iterable<?> expected, @Nullable Iterable<?> actual)	Assert that expected and actual iterables are deeply equal.
static void	assertIterableEquals(@Nullable Iterable<?> expected, @Nullable Iterable<?> actual, @Nullable String message)	Assert that expected and actual iterables are deeply equal.
static void	assertIterableEquals(@Nullable Iterable<?> expected, @Nullable Iterable<?> actual, Supplier<@Nullable String> messageSupplier)	Assert that expected and actual iterables are deeply equal.
static void	assertLinesMatch(List<String> expectedLines, List<String> actualLines)	Assert that expected list of Strings matches actual list.
static void	assertLinesMatch(List<String> expectedLines, List<String> actualLines, @Nullable String message)	Assert that expected list of Strings matches actual list.
static void	assertLinesMatch(List<String> expectedLines, List<String> actualLines, Supplier<@Nullable String> messageSupplier)	Assert that expected list of Strings matches actual list.
static void	assertLinesMatch(Stream<String> expectedLines, Stream<String> actualLines)	Assert that expected stream of Strings matches actual stream.
static void	assertLinesMatch(Stream<String> expectedLines, Stream<String> actualLines, @Nullable String message)	Assert that expected stream of Strings matches actual stream.
static void	assertLinesMatch(Stream<String> expectedLines, Stream<String> actualLines, Supplier<@Nullable String> messageSupplier)	Assert that expected stream of Strings matches actual stream.
static void	assertNotEquals(byte unexpected, byte actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(byte unexpected, byte actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(byte unexpected, byte actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(byte unexpected, @Nullable Byte actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(byte unexpected, @Nullable Byte actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(byte unexpected, @Nullable Byte actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(char unexpected, char actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(char unexpected, char actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(char unexpected, char actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(char unexpected, @Nullable Character actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(char unexpected, @Nullable Character actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(char unexpected, @Nullable Character actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(double unexpected, double actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(double unexpected, double actual, double delta)	Assert that unexpected and actual are not equal within the given delta.
static void	assertNotEquals(double unexpected, double actual, double delta, @Nullable String message)	Assert that unexpected and actual are not equal within the given delta.
static void	assertNotEquals(double unexpected, double actual, double delta, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal within the given delta.
static void	assertNotEquals(double unexpected, double actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(double unexpected, double actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(double unexpected, @Nullable Double actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(double unexpected, @Nullable Double actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(double unexpected, @Nullable Double actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(float unexpected, float actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(float unexpected, float actual, float delta)	Assert that unexpected and actual are not equal within the given delta.
static void	assertNotEquals(float unexpected, float actual, float delta, @Nullable String message)	Assert that unexpected and actual are not equal within the given delta.
static void	assertNotEquals(float unexpected, float actual, float delta, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal within the given delta.
static void	assertNotEquals(float unexpected, float actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(float unexpected, float actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(float unexpected, @Nullable Float actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(float unexpected, @Nullable Float actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(float unexpected, @Nullable Float actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(int unexpected, int actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(int unexpected, int actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(int unexpected, int actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(int unexpected, @Nullable Integer actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(int unexpected, @Nullable Integer actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(int unexpected, @Nullable Integer actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(long unexpected, long actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(long unexpected, long actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(long unexpected, long actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(long unexpected, @Nullable Long actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(long unexpected, @Nullable Long actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(long unexpected, @Nullable Long actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(short unexpected, short actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(short unexpected, short actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(short unexpected, short actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(short unexpected, @Nullable Short actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(short unexpected, @Nullable Short actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(short unexpected, @Nullable Short actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Byte unexpected, byte actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Byte unexpected, byte actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Byte unexpected, byte actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Byte unexpected, @Nullable Byte actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Byte unexpected, @Nullable Byte actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Byte unexpected, @Nullable Byte actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Character unexpected, char actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Character unexpected, char actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Character unexpected, char actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Character unexpected, @Nullable Character actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Character unexpected, @Nullable Character actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Character unexpected, @Nullable Character actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Double unexpected, double actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Double unexpected, double actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Double unexpected, double actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Double unexpected, @Nullable Double actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Double unexpected, @Nullable Double actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Double unexpected, @Nullable Double actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Float unexpected, float actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Float unexpected, float actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Float unexpected, float actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Float unexpected, @Nullable Float actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Float unexpected, @Nullable Float actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Float unexpected, @Nullable Float actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Integer unexpected, int actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Integer unexpected, int actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Integer unexpected, int actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Integer unexpected, @Nullable Integer actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Integer unexpected, @Nullable Integer actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Integer unexpected, @Nullable Integer actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Long unexpected, long actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Long unexpected, long actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Long unexpected, long actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Long unexpected, @Nullable Long actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Long unexpected, @Nullable Long actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Long unexpected, @Nullable Long actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Object unexpected, @Nullable Object actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Object unexpected, @Nullable Object actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Object unexpected, @Nullable Object actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Short unexpected, short actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Short unexpected, short actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Short unexpected, short actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Short unexpected, @Nullable Short actual)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Short unexpected, @Nullable Short actual, @Nullable String message)	Assert that unexpected and actual are not equal.
static void	assertNotEquals(@Nullable Short unexpected, @Nullable Short actual, Supplier<@Nullable String> messageSupplier)	Assert that unexpected and actual are not equal.
static void	assertNotNull(@Nullable Object actual)	Assert that actual is not null.
static void	assertNotNull(@Nullable Object actual, @Nullable String message)	Assert that actual is not null.
static void	assertNotNull(@Nullable Object actual, Supplier<@Nullable String> messageSupplier)	Assert that actual is not null.
static void	assertNotSame(@Nullable Object unexpected, @Nullable Object actual)	Assert that the unexpected object and the actual object are not the same object.
static void	assertNotSame(@Nullable Object unexpected, @Nullable Object actual, @Nullable String message)	Assert that the unexpected object and the actual object are not the same object.
static void	assertNotSame(@Nullable Object unexpected, @Nullable Object actual, Supplier<@Nullable String> messageSupplier)	Assert that the unexpected object and the actual object are not the same object.
static void	assertNull(@Nullable Object actual)	Assert that actual is null.
static void	assertNull(@Nullable Object actual, @Nullable String message)	Assert that actual is null.
static void	assertNull(@Nullable Object actual, Supplier<@Nullable String> messageSupplier)	Assert that actual is null.
static void	assertSame(@Nullable Object expected, @Nullable Object actual)	Assert that the expected object and the actual object are the same object.
static void	assertSame(@Nullable Object expected, @Nullable Object actual, @Nullable String message)	Assert that the expected object and the actual object are the same object.
static void	assertSame(@Nullable Object expected, @Nullable Object actual, Supplier<@Nullable String> messageSupplier)	Assert that the expected object and the actual object are the same object.
static <T extends Throwable> T	assertThrows(Class<T> expectedType, Executable executable)	Assert that execution of the supplied executable throws an exception of the expectedType and return the exception.
static <T extends Throwable> T	assertThrows(Class<T> expectedType, Executable executable, @Nullable String message)	Assert that execution of the supplied executable throws an exception of the expectedType and return the exception.
static <T extends Throwable> T	assertThrows(Class<T> expectedType, Executable executable, Supplier<@Nullable String> messageSupplier)	Assert that execution of the supplied executable throws an exception of the expectedType and return the exception.
static <T extends Throwable> T	assertThrowsExactly(Class<T> expectedType, Executable executable)	Assert that execution of the supplied executable throws an exception of exactly the expectedType and return the exception.
static <T extends Throwable> T	assertThrowsExactly(Class<T> expectedType, Executable executable, @Nullable String message)	Assert that execution of the supplied executable throws an exception of exactly the expectedType and return the exception.
static <T extends Throwable> T	assertThrowsExactly(Class<T> expectedType, Executable executable, Supplier<@Nullable String> messageSupplier)	Assert that execution of the supplied executable throws an exception of exactly the expectedType and return the exception.
static void	assertTimeout(Duration timeout, Executable executable)	Assert that execution of the supplied executable completes before the given timeout is exceeded.
static void	assertTimeout(Duration timeout, Executable executable, @Nullable String message)	Assert that execution of the supplied executable completes before the given timeout is exceeded.
static void	assertTimeout(Duration timeout, Executable executable, Supplier<@Nullable String> messageSupplier)	Assert that execution of the supplied executable completes before the given timeout is exceeded.
static <T extends @Nullable Object> T	assertTimeout(Duration timeout, ThrowingSupplier<T> supplier)	Assert that execution of the supplied supplier completes before the given timeout is exceeded.
static <T extends @Nullable Object> T	assertTimeout(Duration timeout, ThrowingSupplier<T> supplier, @Nullable String message)	Assert that execution of the supplied supplier completes before the given timeout is exceeded.
static <T extends @Nullable Object> T	assertTimeout(Duration timeout, ThrowingSupplier<T> supplier, Supplier<@Nullable String> messageSupplier)	Assert that execution of the supplied supplier completes before the given timeout is exceeded.
static void	assertTimeoutPreemptively(Duration timeout, Executable executable)	Assert that execution of the supplied executable completes before the given timeout is exceeded.
static void	assertTimeoutPreemptively(Duration timeout, Executable executable, @Nullable String message)	Assert that execution of the supplied executable completes before the given timeout is exceeded.
static void	assertTimeoutPreemptively(Duration timeout, Executable executable, Supplier<@Nullable String> messageSupplier)	Assert that execution of the supplied executable completes before the given timeout is exceeded.
static <T extends @Nullable Object> T	assertTimeoutPreemptively(Duration timeout, ThrowingSupplier<T> supplier)	Assert that execution of the supplied supplier completes before the given timeout is exceeded.
static <T extends @Nullable Object> T	assertTimeoutPreemptively(Duration timeout, ThrowingSupplier<T> supplier, @Nullable String message)	Assert that execution of the supplied supplier completes before the given timeout is exceeded.
static <T extends @Nullable Object> T	assertTimeoutPreemptively(Duration timeout, ThrowingSupplier<T> supplier, Supplier<@Nullable String> messageSupplier)	Assert that execution of the supplied supplier completes before the given timeout is exceeded.
static void	assertTrue(boolean condition)	Assert that the supplied condition is true.
static void	assertTrue(boolean condition, @Nullable String message)	Assert that the supplied condition is true.
static void	assertTrue(boolean condition, Supplier<@Nullable String> messageSupplier)	Assert that the supplied condition is true.
static void	assertTrue(BooleanSupplier booleanSupplier)	Assert that the boolean condition supplied by booleanSupplier is true.
static void	assertTrue(BooleanSupplier booleanSupplier, @Nullable String message)	Assert that the boolean condition supplied by booleanSupplier is true.
static void	assertTrue(BooleanSupplier booleanSupplier, Supplier<@Nullable String> messageSupplier)	Assert that the boolean condition supplied by booleanSupplier is true.
static <V> V	fail()	Fail the test without a failure message.
static <V> V	fail(@Nullable String message)	Fail the test with the given failure message.
static <V> V	fail(@Nullable String message, @Nullable Throwable cause)	Fail the test with the given failure message as well as the underlying cause.
static <V> V	fail(@Nullable Throwable cause)	Fail the test with the given underlying cause.
static <V> V	fail(Supplier<@Nullable String> messageSupplier)	Fail the test with the failure message retrieved from the given messageSupplier.

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Details

Assertions

@API(status=STABLE,
     since="5.3")
protected Assertions()

Protected constructor allowing subclassing but not direct instantiation.

Since:

5.3

Method Details

fail

@Contract(" -> fail")
public static <V> V fail()

Fail the test without a failure message.

Although failing with an explicit failure message is recommended, this method may be useful when maintaining legacy code.

See Javadoc for fail(String) for an explanation of this method's generic return type V.

fail

@Contract("_ -> fail")
public static <V> V fail(@Nullable String message)

Fail the test with the given failure message.

The generic return type V allows this method to be used directly as a single-statement lambda expression, thereby avoiding the need to implement a code block with an explicit return value. Since this method throws an AssertionFailedError before its return statement, this method never actually returns a value to its caller. The following example demonstrates how this may be used in practice.

Stream.of().map(entry -> fail("should not be called"));

fail

@Contract("_, _ -> fail")
public static <V> V fail(@Nullable String message,
 @Nullable Throwable cause)

Fail the test with the given failure message as well as the underlying cause.

See Javadoc for fail(String) for an explanation of this method's generic return type V.

fail

@Contract("_ -> fail")
public static <V> V fail(@Nullable Throwable cause)

Fail the test with the given underlying cause.

See Javadoc for fail(String) for an explanation of this method's generic return type V.

fail

@Contract("_ -> fail")
public static <V> V fail(Supplier<@Nullable String> messageSupplier)

Fail the test with the failure message retrieved from the given messageSupplier.

See Javadoc for fail(String) for an explanation of this method's generic return type V.

assertTrue

@Contract("false -> fail")
public static void assertTrue(boolean condition)

Assert that the supplied condition is true.

assertTrue

@Contract("false, _ -> fail")
public static void assertTrue(boolean condition,
 Supplier<@Nullable String> messageSupplier)

Assert that the supplied condition is true.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertTrue

public static void assertTrue(BooleanSupplier booleanSupplier)

Assert that the boolean condition supplied by booleanSupplier is true.

assertTrue

public static void assertTrue(BooleanSupplier booleanSupplier,
 @Nullable String message)

Assert that the boolean condition supplied by booleanSupplier is true.

Fails with the supplied failure message.

assertTrue

@Contract("false, _ -> fail")
public static void assertTrue(boolean condition,
 @Nullable String message)

Assert that the supplied condition is true.

Fails with the supplied failure message.

assertTrue

public static void assertTrue(BooleanSupplier booleanSupplier,
 Supplier<@Nullable String> messageSupplier)

Assert that the boolean condition supplied by booleanSupplier is true.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertFalse

@Contract("true -> fail")
public static void assertFalse(boolean condition)

Assert that the supplied condition is false.

assertFalse

@Contract("true, _ -> fail")
public static void assertFalse(boolean condition,
 @Nullable String message)

Assert that the supplied condition is false.

Fails with the supplied failure message.

assertFalse

@Contract("true, _ -> fail")
public static void assertFalse(boolean condition,
 Supplier<@Nullable String> messageSupplier)

Assert that the supplied condition is false.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertFalse

public static void assertFalse(BooleanSupplier booleanSupplier)

Assert that the boolean condition supplied by booleanSupplier is false.

assertFalse

public static void assertFalse(BooleanSupplier booleanSupplier,
 @Nullable String message)

Assert that the boolean condition supplied by booleanSupplier is false.

Fails with the supplied failure message.

assertFalse

public static void assertFalse(BooleanSupplier booleanSupplier,
 Supplier<@Nullable String> messageSupplier)

Assert that the boolean condition supplied by booleanSupplier is false.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertNull

@Contract("!null -> fail")
public static void assertNull(@Nullable Object actual)

Assert that actual is null.

assertNull

@Contract("!null, _ -> fail")
public static void assertNull(@Nullable Object actual,
 @Nullable String message)

Assert that actual is null.

Fails with the supplied failure message.

assertNull

@Contract("!null, _ -> fail")
public static void assertNull(@Nullable Object actual,
 Supplier<@Nullable String> messageSupplier)

Assert that actual is null.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertNotNull

@Contract("null -> fail")
public static void assertNotNull(@Nullable Object actual)

Assert that actual is not null.

assertNotNull

@Contract("null, _ -> fail")
public static void assertNotNull(@Nullable Object actual,
 @Nullable String message)

Assert that actual is not null.

Fails with the supplied failure message.

assertNotNull

@Contract("null, _ -> fail")
public static void assertNotNull(@Nullable Object actual,
 Supplier<@Nullable String> messageSupplier)

Assert that actual is not null.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

public static void assertEquals(short expected,
 short actual)

Assert that expected and actual are equal.

assertEquals

public static void assertEquals(short expected,
 @Nullable Short actual)

Assert that expected and actual are equal.

assertEquals

public static void assertEquals(@Nullable Short expected,
 short actual)

Assert that expected and actual are equal.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Short expected,
 @Nullable Short actual)

Assert that expected and actual are equal.

Since:

5.4

assertEquals

public static void assertEquals(short expected,
 short actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

assertEquals

public static void assertEquals(short expected,
 @Nullable Short actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

assertEquals

public static void assertEquals(@Nullable Short expected,
 short actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Short expected,
 @Nullable Short actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

Since:

5.4

assertEquals

public static void assertEquals(short expected,
 short actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

public static void assertEquals(short expected,
 @Nullable Short actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

public static void assertEquals(@Nullable Short expected,
 short actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Short expected,
 @Nullable Short actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertEquals

public static void assertEquals(byte expected,
 byte actual)

Assert that expected and actual are equal.

assertEquals

public static void assertEquals(byte expected,
 @Nullable Byte actual)

Assert that expected and actual are equal.

assertEquals

public static void assertEquals(@Nullable Byte expected,
 byte actual)

Assert that expected and actual are equal.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Byte expected,
 @Nullable Byte actual)

Assert that expected and actual are equal.

Since:

5.4

assertEquals

public static void assertEquals(byte expected,
 byte actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

assertEquals

public static void assertEquals(byte expected,
 @Nullable Byte actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

assertEquals

public static void assertEquals(@Nullable Byte expected,
 byte actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Byte expected,
 @Nullable Byte actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

Since:

5.4

assertEquals

public static void assertEquals(byte expected,
 byte actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

public static void assertEquals(byte expected,
 @Nullable Byte actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

public static void assertEquals(@Nullable Byte expected,
 byte actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Byte expected,
 @Nullable Byte actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertEquals

public static void assertEquals(int expected,
 int actual)

Assert that expected and actual are equal.

assertEquals

public static void assertEquals(int expected,
 @Nullable Integer actual)

Assert that expected and actual are equal.

assertEquals

public static void assertEquals(@Nullable Integer expected,
 int actual)

Assert that expected and actual are equal.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Integer expected,
 @Nullable Integer actual)

Assert that expected and actual are equal.

Since:

5.4

assertEquals

public static void assertEquals(int expected,
 int actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

assertEquals

public static void assertEquals(int expected,
 @Nullable Integer actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

assertEquals

public static void assertEquals(@Nullable Integer expected,
 int actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Integer expected,
 @Nullable Integer actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

Since:

5.4

assertEquals

public static void assertEquals(int expected,
 int actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

public static void assertEquals(int expected,
 @Nullable Integer actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

public static void assertEquals(@Nullable Integer expected,
 int actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Integer expected,
 @Nullable Integer actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertEquals

public static void assertEquals(long expected,
 long actual)

Assert that expected and actual are equal.

assertEquals

public static void assertEquals(long expected,
 @Nullable Long actual)

Assert that expected and actual are equal.

assertEquals

public static void assertEquals(@Nullable Long expected,
 long actual)

Assert that expected and actual are equal.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Long expected,
 @Nullable Long actual)

Assert that expected and actual are equal.

Since:

5.4

assertEquals

public static void assertEquals(long expected,
 long actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

assertEquals

public static void assertEquals(long expected,
 @Nullable Long actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

assertEquals

public static void assertEquals(@Nullable Long expected,
 long actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Long expected,
 @Nullable Long actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

Since:

5.4

assertEquals

public static void assertEquals(long expected,
 long actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

public static void assertEquals(long expected,
 @Nullable Long actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

public static void assertEquals(@Nullable Long expected,
 long actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Long expected,
 @Nullable Long actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertEquals

public static void assertEquals(float expected,
 float actual)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

assertEquals

public static void assertEquals(float expected,
 @Nullable Float actual)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

assertEquals

public static void assertEquals(@Nullable Float expected,
 float actual)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Float expected,
 @Nullable Float actual)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Since:

5.4

assertEquals

public static void assertEquals(float expected,
 float actual,
 @Nullable String message)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Fails with the supplied failure message.

assertEquals

public static void assertEquals(float expected,
 @Nullable Float actual,
 @Nullable String message)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Fails with the supplied failure message.

assertEquals

public static void assertEquals(@Nullable Float expected,
 float actual,
 @Nullable String message)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Fails with the supplied failure message.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Float expected,
 @Nullable Float actual,
 @Nullable String message)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Fails with the supplied failure message.

Since:

5.4

assertEquals

public static void assertEquals(float expected,
 float actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

public static void assertEquals(float expected,
 @Nullable Float actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

public static void assertEquals(@Nullable Float expected,
 float actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Float expected,
 @Nullable Float actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertEquals

public static void assertEquals(float expected,
 float actual,
 float delta)

Assert that expected and actual are equal within the given non-negative delta.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

assertEquals

public static void assertEquals(float expected,
 float actual,
 float delta,
 @Nullable String message)

Assert that expected and actual are equal within the given non-negative delta.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Fails with the supplied failure message.

assertEquals

public static void assertEquals(float expected,
 float actual,
 float delta,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal within the given non-negative delta.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

public static void assertEquals(double expected,
 double actual)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

assertEquals

public static void assertEquals(double expected,
 @Nullable Double actual)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

assertEquals

public static void assertEquals(@Nullable Double expected,
 double actual)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Double expected,
 @Nullable Double actual)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Since:

5.4

assertEquals

public static void assertEquals(double expected,
 double actual,
 @Nullable String message)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Fails with the supplied failure message.

assertEquals

public static void assertEquals(double expected,
 @Nullable Double actual,
 @Nullable String message)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Fails with the supplied failure message.

assertEquals

public static void assertEquals(@Nullable Double expected,
 double actual,
 @Nullable String message)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Fails with the supplied failure message.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Double expected,
 @Nullable Double actual,
 @Nullable String message)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Fails with the supplied failure message.

Since:

5.4

assertEquals

public static void assertEquals(double expected,
 double actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

public static void assertEquals(double expected,
 @Nullable Double actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

public static void assertEquals(@Nullable Double expected,
 double actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Double expected,
 @Nullable Double actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertEquals

public static void assertEquals(double expected,
 double actual,
 double delta)

Assert that expected and actual are equal within the given non-negative delta.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

assertEquals

public static void assertEquals(double expected,
 double actual,
 double delta,
 @Nullable String message)

Assert that expected and actual are equal within the given non-negative delta.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Fails with the supplied failure message.

assertEquals

public static void assertEquals(double expected,
 double actual,
 double delta,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal within the given non-negative delta.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

public static void assertEquals(char expected,
 char actual)

Assert that expected and actual are equal.

assertEquals

public static void assertEquals(char expected,
 @Nullable Character actual)

Assert that expected and actual are equal.

assertEquals

public static void assertEquals(@Nullable Character expected,
 char actual)

Assert that expected and actual are equal.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Character expected,
 @Nullable Character actual)

Assert that expected and actual are equal.

Since:

5.4

assertEquals

public static void assertEquals(char expected,
 char actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

assertEquals

public static void assertEquals(char expected,
 @Nullable Character actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

assertEquals

public static void assertEquals(@Nullable Character expected,
 char actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Character expected,
 @Nullable Character actual,
 @Nullable String message)

Assert that expected and actual are equal.

Fails with the supplied failure message.

Since:

5.4

assertEquals

public static void assertEquals(char expected,
 char actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

public static void assertEquals(char expected,
 @Nullable Character actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

public static void assertEquals(@Nullable Character expected,
 char actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertEquals

@API(status=STABLE,
     since="5.4")
public static void assertEquals(@Nullable Character expected,
 @Nullable Character actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertEquals

public static void assertEquals(@Nullable Object expected,
 @Nullable Object actual)

Assert that expected and actual are equal.

If both are null, they are considered equal.

See Also:

• Object.equals(Object)

assertEquals

public static void assertEquals(@Nullable Object expected,
 @Nullable Object actual,
 @Nullable String message)

Assert that expected and actual are equal.

If both are null, they are considered equal.

Fails with the supplied failure message.

See Also:

• Object.equals(Object)

assertEquals

public static void assertEquals(@Nullable Object expected,
 @Nullable Object actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual are equal.

If both are null, they are considered equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

See Also:

• Object.equals(Object)

assertArrayEquals

public static void assertArrayEquals(boolean @Nullable [] expected,
 boolean @Nullable [] actual)

Assert that expected and actual boolean arrays are equal.

If both are null, they are considered equal.

assertArrayEquals

public static void assertArrayEquals(boolean @Nullable [] expected,
 boolean @Nullable [] actual,
 @Nullable String message)

Assert that expected and actual boolean arrays are equal.

If both are null, they are considered equal.

Fails with the supplied failure message.

assertArrayEquals

public static void assertArrayEquals(boolean @Nullable [] expected,
 boolean @Nullable [] actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual boolean arrays are equal.

If both are null, they are considered equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertArrayEquals

public static void assertArrayEquals(char @Nullable [] expected,
 char @Nullable [] actual)

Assert that expected and actual char arrays are equal.

If both are null, they are considered equal.

assertArrayEquals

public static void assertArrayEquals(char @Nullable [] expected,
 char @Nullable [] actual,
 @Nullable String message)

Assert that expected and actual char arrays are equal.

If both are null, they are considered equal.

Fails with the supplied failure message.

assertArrayEquals

public static void assertArrayEquals(char @Nullable [] expected,
 char @Nullable [] actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual char arrays are equal.

If both are null, they are considered equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertArrayEquals

public static void assertArrayEquals(byte @Nullable [] expected,
 byte @Nullable [] actual)

Assert that expected and actual byte arrays are equal.

If both are null, they are considered equal.

assertArrayEquals

public static void assertArrayEquals(byte @Nullable [] expected,
 byte @Nullable [] actual,
 @Nullable String message)

Assert that expected and actual byte arrays are equal.

If both are null, they are considered equal.

Fails with the supplied failure message.

assertArrayEquals

public static void assertArrayEquals(byte @Nullable [] expected,
 byte @Nullable [] actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual byte arrays are equal.

If both are null, they are considered equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertArrayEquals

public static void assertArrayEquals(short @Nullable [] expected,
 short @Nullable [] actual)

Assert that expected and actual short arrays are equal.

If both are null, they are considered equal.

assertArrayEquals

public static void assertArrayEquals(short @Nullable [] expected,
 short @Nullable [] actual,
 @Nullable String message)

Assert that expected and actual short arrays are equal.

If both are null, they are considered equal.

Fails with the supplied failure message.

assertArrayEquals

public static void assertArrayEquals(short @Nullable [] expected,
 short @Nullable [] actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual short arrays are equal.

If both are null, they are considered equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertArrayEquals

public static void assertArrayEquals(int @Nullable [] expected,
 int @Nullable [] actual)

Assert that expected and actual int arrays are equal.

If both are null, they are considered equal.

assertArrayEquals

public static void assertArrayEquals(int @Nullable [] expected,
 int @Nullable [] actual,
 @Nullable String message)

Assert that expected and actual int arrays are equal.

If both are null, they are considered equal.

Fails with the supplied failure message.

assertArrayEquals

public static void assertArrayEquals(int @Nullable [] expected,
 int @Nullable [] actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual int arrays are equal.

If both are null, they are considered equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertArrayEquals

public static void assertArrayEquals(long @Nullable [] expected,
 long @Nullable [] actual)

Assert that expected and actual long arrays are equal.

If both are null, they are considered equal.

assertArrayEquals

public static void assertArrayEquals(long @Nullable [] expected,
 long @Nullable [] actual,
 @Nullable String message)

Assert that expected and actual long arrays are equal.

If both are null, they are considered equal.

Fails with the supplied failure message.

assertArrayEquals

public static void assertArrayEquals(long @Nullable [] expected,
 long @Nullable [] actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual long arrays are equal.

If both are null, they are considered equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertArrayEquals

public static void assertArrayEquals(float @Nullable [] expected,
 float @Nullable [] actual)

Assert that expected and actual float arrays are equal.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

assertArrayEquals

public static void assertArrayEquals(float @Nullable [] expected,
 float @Nullable [] actual,
 @Nullable String message)

Assert that expected and actual float arrays are equal.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Fails with the supplied failure message.

assertArrayEquals

public static void assertArrayEquals(float @Nullable [] expected,
 float @Nullable [] actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual float arrays are equal.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertArrayEquals

public static void assertArrayEquals(float @Nullable [] expected,
 float @Nullable [] actual,
 float delta)

Assert that expected and actual float arrays are equal within the given non-negative delta.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

assertArrayEquals

public static void assertArrayEquals(float @Nullable [] expected,
 float @Nullable [] actual,
 float delta,
 @Nullable String message)

Assert that expected and actual float arrays are equal within the given non-negative delta.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Fails with the supplied failure message.

assertArrayEquals

public static void assertArrayEquals(float @Nullable [] expected,
 float @Nullable [] actual,
 float delta,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual float arrays are equal within the given non-negative delta.

Equality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertArrayEquals

public static void assertArrayEquals(double @Nullable [] expected,
 double @Nullable [] actual)

Assert that expected and actual double arrays are equal.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

assertArrayEquals

public static void assertArrayEquals(double @Nullable [] expected,
 double @Nullable [] actual,
 @Nullable String message)

Assert that expected and actual double arrays are equal.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Fails with the supplied failure message.

assertArrayEquals

public static void assertArrayEquals(double @Nullable [] expected,
 double @Nullable [] actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual double arrays are equal.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertArrayEquals

public static void assertArrayEquals(double @Nullable [] expected,
 double @Nullable [] actual,
 double delta)

Assert that expected and actual double arrays are equal within the given non-negative delta.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

assertArrayEquals

public static void assertArrayEquals(double @Nullable [] expected,
 double @Nullable [] actual,
 double delta,
 @Nullable String message)

Assert that expected and actual double arrays are equal within the given non-negative delta.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Fails with the supplied failure message.

assertArrayEquals

public static void assertArrayEquals(double @Nullable [] expected,
 double @Nullable [] actual,
 double delta,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual double arrays are equal within the given non-negative delta.

Equality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertArrayEquals

public static void assertArrayEquals(@Nullable Object @Nullable [] expected,
 @Nullable Object @Nullable [] actual)

Assert that expected and actual object arrays are deeply equal.

If both are null, they are considered equal.

Nested float arrays are checked as in assertEquals(float, float).

Nested double arrays are checked as in assertEquals(double, double).

See Also:

• Objects.equals(Object, Object)
• Arrays.deepEquals(Object[], Object[])

assertArrayEquals

public static void assertArrayEquals(@Nullable Object @Nullable [] expected,
 @Nullable Object @Nullable [] actual,
 @Nullable String message)

Assert that expected and actual object arrays are deeply equal.

If both are null, they are considered equal.

Nested float arrays are checked as in assertEquals(float, float).

Nested double arrays are checked as in assertEquals(double, double).

Fails with the supplied failure message.

See Also:

• Objects.equals(Object, Object)
• Arrays.deepEquals(Object[], Object[])

assertArrayEquals

public static void assertArrayEquals(@Nullable Object @Nullable [] expected,
 @Nullable Object @Nullable [] actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual object arrays are deeply equal.

If both are null, they are considered equal.

Nested float arrays are checked as in assertEquals(float, float).

Nested double arrays are checked as in assertEquals(double, double).

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

See Also:

• Objects.equals(Object, Object)
• Arrays.deepEquals(Object[], Object[])

assertIterableEquals

public static void assertIterableEquals(@Nullable Iterable<?> expected,
 @Nullable Iterable<?> actual)

Assert that expected and actual iterables are deeply equal.

Similarly to the check for deep equality in assertArrayEquals(Object[], Object[]), if two iterables are encountered (including expected and actual) then their iterators must return equal elements in the same order as each other. Note: this means that the iterables do not need to be of the same type. Example:

import static java.util.Arrays.asList;
 ...
Iterable<Integer> i0 = new ArrayList<>(asList(1, 2, 3));
Iterable<Integer> i1 = new LinkedList<>(asList(1, 2, 3));
assertIterableEquals(i0, i1); // Passes

If both expected and actual are null, they are considered equal.

See Also:

• Objects.equals(Object, Object)
• Arrays.deepEquals(Object[], Object[])
• assertArrayEquals(Object[], Object[])

assertIterableEquals

public static void assertIterableEquals(@Nullable Iterable<?> expected,
 @Nullable Iterable<?> actual,
 @Nullable String message)

Assert that expected and actual iterables are deeply equal.

Similarly to the check for deep equality in assertArrayEquals(Object[], Object[], String), if two iterables are encountered (including expected and actual) then their iterators must return equal elements in the same order as each other. Note: this means that the iterables do not need to be of the same type. Example:

import static java.util.Arrays.asList;
 ...
Iterable<Integer> i0 = new ArrayList<>(asList(1, 2, 3));
Iterable<Integer> i1 = new LinkedList<>(asList(1, 2, 3));
assertIterableEquals(i0, i1); // Passes

If both expected and actual are null, they are considered equal.

Fails with the supplied failure message.

See Also:

• Objects.equals(Object, Object)
• Arrays.deepEquals(Object[], Object[])
• assertArrayEquals(Object[], Object[], String)

assertIterableEquals

public static void assertIterableEquals(@Nullable Iterable<?> expected,
 @Nullable Iterable<?> actual,
 Supplier<@Nullable String> messageSupplier)

Assert that expected and actual iterables are deeply equal.

Similarly to the check for deep equality in assertArrayEquals(Object[], Object[], Supplier), if two iterables are encountered (including expected and actual) then their iterators must return equal elements in the same order as each other. Note: this means that the iterables do not need to be of the same type. Example:

import static java.util.Arrays.asList;
 ...
Iterable<Integer> i0 = new ArrayList<>(asList(1, 2, 3));
Iterable<Integer> i1 = new LinkedList<>(asList(1, 2, 3));
assertIterableEquals(i0, i1); // Passes

If both expected and actual are null, they are considered equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

See Also:

• Objects.equals(Object, Object)
• Arrays.deepEquals(Object[], Object[])
• assertArrayEquals(Object[], Object[], Supplier)

assertLinesMatch

public static void assertLinesMatch(List<String> expectedLines,
 List<String> actualLines)

Assert that expected list of Strings matches actual list.

This method differs from other assertions that effectively only check String.equals(Object), in that it uses the following staged matching algorithm:

For each pair of expected and actual lines do

1. check if expected.equals(actual) - if yes, continue with next pair
2. otherwise treat expected as a regular expression and check via String.matches(String) - if yes, continue with next pair
3. otherwise check if expected line is a fast-forward marker, if yes apply fast-forward actual lines accordingly (see below) and goto 1.

A valid fast-forward marker is an expected line that starts and ends with the literal >> and contains at least 4 characters. Examples:

• >>>>
>> stacktrace >>
>> single line, non Integer.parse()-able comment >>
  Skip arbitrary number of actual lines, until first matching subsequent expected line is found. Any character between the fast-forward literals are discarded.
• ">> 21 >>"
  Skip strictly 21 lines. If they can't be skipped for any reason, an assertion error is raised.

Here is an example showing all three kinds of expected line formats:

ls -la /
total [\d]+
drwxr-xr-x  0 root root   512 Jan  1  1970 .
drwxr-xr-x  0 root root   512 Jan  1  1970 ..
drwxr-xr-x  0 root root   512 Apr  5 07:45 bin
>> 4 >>
-rwxr-xr-x  1 root root [\d]+ Jan  1  1970 init
>> M A N Y  M O R E  E N T R I E S >>
drwxr-xr-x  0 root root   512 Sep 22  2017 var

Fails with a generated failure message describing the difference.

assertLinesMatch

public static void assertLinesMatch(List<String> expectedLines,
 List<String> actualLines,
 @Nullable String message)

Assert that expected list of Strings matches actual list.

Find a detailed description of the matching algorithm in assertLinesMatch(List, List).

Fails with the supplied failure message and the generated message.

See Also:

• assertLinesMatch(List, List)

assertLinesMatch

public static void assertLinesMatch(List<String> expectedLines,
 List<String> actualLines,
 Supplier<@Nullable String> messageSupplier)

Assert that expected list of Strings matches actual list.

Find a detailed description of the matching algorithm in assertLinesMatch(List, List).

If necessary, a custom failure message will be retrieved lazily from the supplied messageSupplier. Fails with the custom failure message prepended to a generated failure message describing the difference.

See Also:

• assertLinesMatch(List, List)

assertLinesMatch

public static void assertLinesMatch(Stream<String> expectedLines,
 Stream<String> actualLines)

Assert that expected stream of Strings matches actual stream.

Find a detailed description of the matching algorithm in assertLinesMatch(List, List).

Note: An implementation of this method may consume all lines of both streams eagerly and delegate the evaluation to assertLinesMatch(List, List).

Since:

5.7

See Also:

• assertLinesMatch(List, List)

assertLinesMatch

public static void assertLinesMatch(Stream<String> expectedLines,
 Stream<String> actualLines,
 @Nullable String message)

Assert that expected stream of Strings matches actual stream.

Find a detailed description of the matching algorithm in assertLinesMatch(List, List).

Fails with the supplied failure message and the generated message.

Note: An implementation of this method may consume all lines of both streams eagerly and delegate the evaluation to assertLinesMatch(List, List).

Since:

5.7

See Also:

• assertLinesMatch(List, List)

assertLinesMatch

public static void assertLinesMatch(Stream<String> expectedLines,
 Stream<String> actualLines,
 Supplier<@Nullable String> messageSupplier)

Assert that expected stream of Strings matches actual stream.

Find a detailed description of the matching algorithm in assertLinesMatch(List, List).

If necessary, a custom failure message will be retrieved lazily from the supplied messageSupplier. Fails with the custom failure message prepended to a generated failure message describing the difference.

Note: An implementation of this method may consume all lines of both streams eagerly and delegate the evaluation to assertLinesMatch(List, List).

Since:

5.7

See Also:

• assertLinesMatch(List, List)

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(byte unexpected,
 byte actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(byte unexpected,
 @Nullable Byte actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Byte unexpected,
 byte actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Byte unexpected,
 @Nullable Byte actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(byte unexpected,
 byte actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(byte unexpected,
 @Nullable Byte actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Byte unexpected,
 byte actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Byte unexpected,
 @Nullable Byte actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(byte unexpected,
 byte actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(byte unexpected,
 @Nullable Byte actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Byte unexpected,
 byte actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Byte unexpected,
 @Nullable Byte actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(short unexpected,
 short actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(short unexpected,
 @Nullable Short actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Short unexpected,
 short actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Short unexpected,
 @Nullable Short actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(short unexpected,
 short actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(short unexpected,
 @Nullable Short actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Short unexpected,
 short actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Short unexpected,
 @Nullable Short actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(short unexpected,
 short actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(short unexpected,
 @Nullable Short actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Short unexpected,
 short actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Short unexpected,
 @Nullable Short actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(int unexpected,
 int actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(int unexpected,
 @Nullable Integer actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Integer unexpected,
 int actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Integer unexpected,
 @Nullable Integer actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(int unexpected,
 int actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(int unexpected,
 @Nullable Integer actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Integer unexpected,
 int actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Integer unexpected,
 @Nullable Integer actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(int unexpected,
 int actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(int unexpected,
 @Nullable Integer actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Integer unexpected,
 int actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Integer unexpected,
 @Nullable Integer actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(long unexpected,
 long actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(long unexpected,
 @Nullable Long actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Long unexpected,
 long actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Long unexpected,
 @Nullable Long actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(long unexpected,
 long actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(long unexpected,
 @Nullable Long actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Long unexpected,
 long actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Long unexpected,
 @Nullable Long actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(long unexpected,
 long actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(long unexpected,
 @Nullable Long actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Long unexpected,
 long actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Long unexpected,
 @Nullable Long actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(float unexpected,
 float actual)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(float unexpected,
 @Nullable Float actual)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Float unexpected,
 float actual)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Float unexpected,
 @Nullable Float actual)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(float unexpected,
 float actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(float unexpected,
 @Nullable Float actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Float unexpected,
 float actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Float unexpected,
 @Nullable Float actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(float unexpected,
 float actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(float unexpected,
 @Nullable Float actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Float unexpected,
 float actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Float unexpected,
 @Nullable Float actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(float unexpected,
 float actual,
 float delta)

Assert that unexpected and actual are not equal within the given delta.

Inequality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(float unexpected,
 float actual,
 float delta,
 @Nullable String message)

Assert that unexpected and actual are not equal within the given delta.

Inequality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(float unexpected,
 float actual,
 float delta,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal within the given delta.

Inequality imposed by this method is consistent with Float.equals(Object) and Float.compare(float, float).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(double unexpected,
 double actual)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(double unexpected,
 @Nullable Double actual)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Double unexpected,
 double actual)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Double unexpected,
 @Nullable Double actual)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(double unexpected,
 double actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(double unexpected,
 @Nullable Double actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Double unexpected,
 double actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Double unexpected,
 @Nullable Double actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(double unexpected,
 double actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(double unexpected,
 @Nullable Double actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Double unexpected,
 double actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Double unexpected,
 @Nullable Double actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

Inequality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(double unexpected,
 double actual,
 double delta)

Assert that unexpected and actual are not equal within the given delta.

Inequality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(double unexpected,
 double actual,
 double delta,
 @Nullable String message)

Assert that unexpected and actual are not equal within the given delta.

Inequality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(double unexpected,
 double actual,
 double delta,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal within the given delta.

Inequality imposed by this method is consistent with Double.equals(Object) and Double.compare(double, double).

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(char unexpected,
 char actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(char unexpected,
 @Nullable Character actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Character unexpected,
 char actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Character unexpected,
 @Nullable Character actual)

Assert that unexpected and actual are not equal.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(char unexpected,
 char actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(char unexpected,
 @Nullable Character actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Character unexpected,
 char actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Character unexpected,
 @Nullable Character actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails with the supplied failure message.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(char unexpected,
 char actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(char unexpected,
 @Nullable Character actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Character unexpected,
 char actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

@API(status=STABLE,
     since="5.4")
public static void assertNotEquals(@Nullable Character unexpected,
 @Nullable Character actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.4

assertNotEquals

public static void assertNotEquals(@Nullable Object unexpected,
 @Nullable Object actual)

Assert that unexpected and actual are not equal.

Fails if both are null.

See Also:

• Object.equals(Object)

assertNotEquals

public static void assertNotEquals(@Nullable Object unexpected,
 @Nullable Object actual,
 @Nullable String message)

Assert that unexpected and actual are not equal.

Fails if both are null.

Fails with the supplied failure message.

See Also:

• Object.equals(Object)

assertNotEquals

public static void assertNotEquals(@Nullable Object unexpected,
 @Nullable Object actual,
 Supplier<@Nullable String> messageSupplier)

Assert that unexpected and actual are not equal.

Fails if both are null.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

See Also:

• Object.equals(Object)

assertSame

public static void assertSame(@Nullable Object expected,
 @Nullable Object actual)

Assert that the expected object and the actual object are the same object.

This method should only be used to assert identity between objects. To assert equality between two objects or two primitive values, use one of the assertEquals(...) methods instead — for example, use assertEquals(999, 999) instead of assertSame(999, 999).

assertSame

public static void assertSame(@Nullable Object expected,
 @Nullable Object actual,
 @Nullable String message)

Assert that the expected object and the actual object are the same object.

This method should only be used to assert identity between objects. To assert equality between two objects or two primitive values, use one of the assertEquals(...) methods instead — for example, use assertEquals(999, 999) instead of assertSame(999, 999).

Fails with the supplied failure message.

assertSame

public static void assertSame(@Nullable Object expected,
 @Nullable Object actual,
 Supplier<@Nullable String> messageSupplier)

Assert that the expected object and the actual object are the same object.

This method should only be used to assert identity between objects. To assert equality between two objects or two primitive values, use one of the assertEquals(...) methods instead — for example, use assertEquals(999, 999) instead of assertSame(999, 999).

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertNotSame

public static void assertNotSame(@Nullable Object unexpected,
 @Nullable Object actual)

Assert that the unexpected object and the actual object are not the same object.

This method should only be used to compare the identity of two objects. To assert that two objects or two primitive values are not equal, use one of the assertNotEquals(...) methods instead.

assertNotSame

public static void assertNotSame(@Nullable Object unexpected,
 @Nullable Object actual,
 @Nullable String message)

Assert that the unexpected object and the actual object are not the same object.

This method should only be used to compare the identity of two objects. To assert that two objects or two primitive values are not equal, use one of the assertNotEquals(...) methods instead.

Fails with the supplied failure message.

assertNotSame

public static void assertNotSame(@Nullable Object unexpected,
 @Nullable Object actual,
 Supplier<@Nullable String> messageSupplier)

Assert that the unexpected object and the actual object are not the same object.

This method should only be used to compare the identity of two objects. To assert that two objects or two primitive values are not equal, use one of the assertNotEquals(...) methods instead.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

assertAll

public static void assertAll(Executable... executables)
                      throws org.opentest4j.MultipleFailuresError

Assert that all supplied executables do not throw exceptions.

See Javadoc for assertAll(String, Stream) for an explanation of this method's exception handling semantics.

Throws:

org.opentest4j.MultipleFailuresError

See Also:

• assertAll(String, Executable...)
• assertAll(Collection)
• assertAll(String, Collection)
• assertAll(Stream)
• assertAll(String, Stream)

assertAll

public static void assertAll(@Nullable String heading,
 Executable... executables)
                      throws org.opentest4j.MultipleFailuresError

Assert that all supplied executables do not throw exceptions.

See Javadoc for assertAll(String, Stream) for an explanation of this method's exception handling semantics.

Throws:

org.opentest4j.MultipleFailuresError

See Also:

• assertAll(Executable...)
• assertAll(Collection)
• assertAll(Stream)
• assertAll(String, Collection)
• assertAll(String, Stream)

assertAll

public static void assertAll(Collection<Executable> executables)
                      throws org.opentest4j.MultipleFailuresError

Assert that all supplied executables do not throw exceptions.

See Javadoc for assertAll(String, Stream) for an explanation of this method's exception handling semantics.

Throws:

org.opentest4j.MultipleFailuresError

See Also:

• assertAll(Executable...)
• assertAll(String, Executable...)
• assertAll(String, Collection)
• assertAll(Stream)
• assertAll(String, Stream)

assertAll

public static void assertAll(@Nullable String heading,
 Collection<Executable> executables)
                      throws org.opentest4j.MultipleFailuresError

Assert that all supplied executables do not throw exceptions.

See Javadoc for assertAll(String, Stream) for an explanation of this method's exception handling semantics.

Throws:

org.opentest4j.MultipleFailuresError

See Also:

• assertAll(Executable...)
• assertAll(String, Executable...)
• assertAll(Collection)
• assertAll(Stream)
• assertAll(String, Stream)

assertAll

public static void assertAll(Stream<Executable> executables)
                      throws org.opentest4j.MultipleFailuresError

Assert that all supplied executables do not throw exceptions.

See Javadoc for assertAll(String, Stream) for an explanation of this method's exception handling semantics.

Throws:

org.opentest4j.MultipleFailuresError

See Also:

• assertAll(Executable...)
• assertAll(String, Executable...)
• assertAll(Collection)
• assertAll(String, Collection)
• assertAll(String, Stream)

assertAll

public static void assertAll(@Nullable String heading,
 Stream<Executable> executables)
                      throws org.opentest4j.MultipleFailuresError

Assert that all supplied executables do not throw exceptions.

If any supplied Executable throws an exception (i.e., a Throwable or any subclass thereof), all remaining executables will still be executed, and all exceptions will be aggregated and reported in a MultipleFailuresError. In addition, all aggregated exceptions will be added as suppressed exceptions to the MultipleFailuresError. However, if one of the executables throws an unrecoverable exception — for example, an OutOfMemoryError — execution will halt immediately, and the unrecoverable exception will be rethrown as is but masked as an unchecked exception.

The supplied heading will be included in the message string for the MultipleFailuresError.

Throws:

org.opentest4j.MultipleFailuresError

See Also:

• assertAll(Executable...)
• assertAll(String, Executable...)
• assertAll(Collection)
• assertAll(String, Collection)
• assertAll(Stream)

assertThrowsExactly

@API(status=STABLE,
     since="5.10")
public static <T extends Throwable> T assertThrowsExactly(Class<T> expectedType,
 Executable executable)

Assert that execution of the supplied executable throws an exception of exactly the expectedType and return the exception.

If no exception is thrown, or if an exception of a different type is thrown, this method will fail.

If you do not want to perform additional checks on the exception instance, ignore the return value.

Since:

5.8

assertThrowsExactly

@API(status=STABLE,
     since="5.10")
public static <T extends Throwable> T assertThrowsExactly(Class<T> expectedType,
 Executable executable,
 @Nullable String message)

Assert that execution of the supplied executable throws an exception of exactly the expectedType and return the exception.

If no exception is thrown, or if an exception of a different type is thrown, this method will fail.

If you do not want to perform additional checks on the exception instance, ignore the return value.

Fails with the supplied failure message. Note that the supplied message is not the expected message of the thrown exception. To assert the expected message of the thrown exception, you must use a separate, subsequent assertion against the exception returned from this method.

Since:

5.8

assertThrowsExactly

@API(status=STABLE,
     since="5.10")
public static <T extends Throwable> T assertThrowsExactly(Class<T> expectedType,
 Executable executable,
 Supplier<@Nullable String> messageSupplier)

Assert that execution of the supplied executable throws an exception of exactly the expectedType and return the exception.

If no exception is thrown, or if an exception of a different type is thrown, this method will fail.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier. Note that the failure message is not the expected message of the thrown exception. To assert the expected message of the thrown exception, you must use a separate, subsequent assertion against the exception returned from this method.

If you do not want to perform additional checks on the exception instance, ignore the return value.

Since:

5.8

assertThrows

public static <T extends Throwable> T assertThrows(Class<T> expectedType,
 Executable executable)

Assert that execution of the supplied executable throws an exception of the expectedType and return the exception.

The assertion passes if the thrown exception type is the same as expectedType or a subtype thereof. To check for the exact thrown type use assertThrowsExactly. If no exception is thrown, or if an exception of a different type is thrown, this method will fail.

If you do not want to perform additional checks on the exception instance, ignore the return value.

See Also:

• assertThrowsExactly(Class, Executable)

assertThrows

public static <T extends Throwable> T assertThrows(Class<T> expectedType,
 Executable executable,
 @Nullable String message)

Assert that execution of the supplied executable throws an exception of the expectedType and return the exception.

The assertion passes if the thrown exception type is the same as expectedType or a subtype thereof. To check for the exact thrown type use assertThrowsExactly. If no exception is thrown, or if an exception of a different type is thrown, this method will fail.

If you do not want to perform additional checks on the exception instance, ignore the return value.

Fails with the supplied failure message. Note that the supplied message is not the expected message of the thrown exception. To assert the expected message of the thrown exception, you must use a separate, subsequent assertion against the exception returned from this method.

See Also:

• assertThrowsExactly(Class, Executable, String)

assertThrows

public static <T extends Throwable> T assertThrows(Class<T> expectedType,
 Executable executable,
 Supplier<@Nullable String> messageSupplier)

Assert that execution of the supplied executable throws an exception of the expectedType and return the exception.

The assertion passes if the thrown exception type is the same as expectedType or a subtype thereof. To check for the exact thrown type use assertThrowsExactly. If no exception is thrown, or if an exception of a different type is thrown, this method will fail.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier. Note that the failure message is not the expected message of the thrown exception. To assert the expected message of the thrown exception, you must use a separate, subsequent assertion against the exception returned from this method.

If you do not want to perform additional checks on the exception instance, ignore the return value.

See Also:

• assertThrowsExactly(Class, Executable, Supplier)

assertDoesNotThrow

@API(status=STABLE,
     since="5.2")
public static void assertDoesNotThrow(Executable executable)

Assert that execution of the supplied executable does not throw any kind of exception.

Usage Note

Although any exception thrown from a test method will cause the test to fail, there are certain use cases where it can be beneficial to explicitly assert that an exception is not thrown for a given code block within a test method.

Since:

5.2

assertDoesNotThrow

@API(status=STABLE,
     since="5.2")
public static void assertDoesNotThrow(Executable executable,
 @Nullable String message)

Assert that execution of the supplied executable does not throw any kind of exception.

Usage Note

Although any exception thrown from a test method will cause the test to fail, there are certain use cases where it can be beneficial to explicitly assert that an exception is not thrown for a given code block within a test method.

Fails with the supplied failure message.

Since:

5.2

assertDoesNotThrow

@API(status=STABLE,
     since="5.2")
public static void assertDoesNotThrow(Executable executable,
 Supplier<@Nullable String> messageSupplier)

Assert that execution of the supplied executable does not throw any kind of exception.

Usage Note

Although any exception thrown from a test method will cause the test to fail, there are certain use cases where it can be beneficial to explicitly assert that an exception is not thrown for a given code block within a test method.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.2

assertDoesNotThrow

@API(status=STABLE,
     since="5.2")
public static <T extends @Nullable Object> T assertDoesNotThrow(ThrowingSupplier<T> supplier)

Assert that execution of the supplied supplier does not throw any kind of exception.

If the assertion passes, the supplier's result will be returned.

Usage Note

Although any exception thrown from a test method will cause the test to fail, there are certain use cases where it can be beneficial to explicitly assert that an exception is not thrown for a given code block within a test method.

Since:

5.2

assertDoesNotThrow

@API(status=STABLE,
     since="5.2")
public static <T extends @Nullable Object> T assertDoesNotThrow(ThrowingSupplier<T> supplier,
 @Nullable String message)

Assert that execution of the supplied supplier does not throw any kind of exception.

If the assertion passes, the supplier's result will be returned.

Fails with the supplied failure message.

Usage Note

Although any exception thrown from a test method will cause the test to fail, there are certain use cases where it can be beneficial to explicitly assert that an exception is not thrown for a given code block within a test method.

Since:

5.2

assertDoesNotThrow

@API(status=STABLE,
     since="5.2")
public static <T extends @Nullable Object> T assertDoesNotThrow(ThrowingSupplier<T> supplier,
 Supplier<@Nullable String> messageSupplier)

Assert that execution of the supplied supplier does not throw any kind of exception.

If the assertion passes, the supplier's result will be returned.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Usage Note

Although any exception thrown from a test method will cause the test to fail, there are certain use cases where it can be beneficial to explicitly assert that an exception is not thrown for a given code block within a test method.

Since:

5.2

assertTimeout

public static void assertTimeout(Duration timeout,
 Executable executable)

Assert that execution of the supplied executable completes before the given timeout is exceeded.

Note: the executable will be executed in the same thread as that of the calling code. Consequently, execution of the executable will not be preemptively aborted if the timeout is exceeded.

See Also:

• assertTimeout(Duration, Executable, String)
• assertTimeout(Duration, Executable, Supplier)
• assertTimeout(Duration, ThrowingSupplier)
• assertTimeout(Duration, ThrowingSupplier, String)
• assertTimeout(Duration, ThrowingSupplier, Supplier)
• assertTimeoutPreemptively(Duration, Executable)

assertTimeout

public static void assertTimeout(Duration timeout,
 Executable executable,
 @Nullable String message)

Assert that execution of the supplied executable completes before the given timeout is exceeded.

Note: the executable will be executed in the same thread as that of the calling code. Consequently, execution of the executable will not be preemptively aborted if the timeout is exceeded.

Fails with the supplied failure message.

See Also:

• assertTimeout(Duration, Executable)
• assertTimeout(Duration, Executable, Supplier)
• assertTimeout(Duration, ThrowingSupplier)
• assertTimeout(Duration, ThrowingSupplier, String)
• assertTimeout(Duration, ThrowingSupplier, Supplier)
• assertTimeoutPreemptively(Duration, Executable, String)

assertTimeout

public static void assertTimeout(Duration timeout,
 Executable executable,
 Supplier<@Nullable String> messageSupplier)

Assert that execution of the supplied executable completes before the given timeout is exceeded.

Note: the executable will be executed in the same thread as that of the calling code. Consequently, execution of the executable will not be preemptively aborted if the timeout is exceeded.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

See Also:

• assertTimeout(Duration, Executable)
• assertTimeout(Duration, Executable, String)
• assertTimeout(Duration, ThrowingSupplier)
• assertTimeout(Duration, ThrowingSupplier, String)
• assertTimeout(Duration, ThrowingSupplier, Supplier)
• assertTimeoutPreemptively(Duration, Executable, Supplier)

assertTimeout

public static <T extends @Nullable Object> T assertTimeout(Duration timeout,
 ThrowingSupplier<T> supplier)

Assert that execution of the supplied supplier completes before the given timeout is exceeded.

If the assertion passes then the supplier's result is returned.

Note: the supplier will be executed in the same thread as that of the calling code. Consequently, execution of the supplier will not be preemptively aborted if the timeout is exceeded.

See Also:

• assertTimeout(Duration, Executable)
• assertTimeout(Duration, Executable, String)
• assertTimeout(Duration, Executable, Supplier)
• assertTimeout(Duration, ThrowingSupplier, String)
• assertTimeout(Duration, ThrowingSupplier, Supplier)
• assertTimeoutPreemptively(Duration, Executable)

assertTimeout

public static <T extends @Nullable Object> T assertTimeout(Duration timeout,
 ThrowingSupplier<T> supplier,
 @Nullable String message)

Assert that execution of the supplied supplier completes before the given timeout is exceeded.

If the assertion passes then the supplier's result is returned.

Note: the supplier will be executed in the same thread as that of the calling code. Consequently, execution of the supplier will not be preemptively aborted if the timeout is exceeded.

Fails with the supplied failure message.

See Also:

• assertTimeout(Duration, Executable)
• assertTimeout(Duration, Executable, String)
• assertTimeout(Duration, Executable, Supplier)
• assertTimeout(Duration, ThrowingSupplier)
• assertTimeout(Duration, ThrowingSupplier, Supplier)
• assertTimeoutPreemptively(Duration, Executable, String)

assertTimeout

public static <T extends @Nullable Object> T assertTimeout(Duration timeout,
 ThrowingSupplier<T> supplier,
 Supplier<@Nullable String> messageSupplier)

Assert that execution of the supplied supplier completes before the given timeout is exceeded.

If the assertion passes then the supplier's result is returned.

Note: the supplier will be executed in the same thread as that of the calling code. Consequently, execution of the supplier will not be preemptively aborted if the timeout is exceeded.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

See Also:

• assertTimeout(Duration, Executable)
• assertTimeout(Duration, Executable, String)
• assertTimeout(Duration, Executable, Supplier)
• assertTimeout(Duration, ThrowingSupplier)
• assertTimeout(Duration, ThrowingSupplier, String)
• assertTimeoutPreemptively(Duration, Executable, Supplier)

assertTimeoutPreemptively

public static void assertTimeoutPreemptively(Duration timeout,
 Executable executable)

Assert that execution of the supplied executable completes before the given timeout is exceeded.

See the Preemptive Timeouts section of the class-level Javadoc for further details.

See Also:

• assertTimeoutPreemptively(Duration, Executable, String)
• assertTimeoutPreemptively(Duration, Executable, Supplier)
• assertTimeoutPreemptively(Duration, ThrowingSupplier)
• assertTimeoutPreemptively(Duration, ThrowingSupplier, String)
• assertTimeoutPreemptively(Duration, ThrowingSupplier, Supplier)
• assertTimeout(Duration, Executable)

assertTimeoutPreemptively

public static void assertTimeoutPreemptively(Duration timeout,
 Executable executable,
 @Nullable String message)

Assert that execution of the supplied executable completes before the given timeout is exceeded.

See the Preemptive Timeouts section of the class-level Javadoc for further details.

Fails with the supplied failure message.

See Also:

• assertTimeoutPreemptively(Duration, Executable)
• assertTimeoutPreemptively(Duration, Executable, Supplier)
• assertTimeoutPreemptively(Duration, ThrowingSupplier)
• assertTimeoutPreemptively(Duration, ThrowingSupplier, String)
• assertTimeoutPreemptively(Duration, ThrowingSupplier, Supplier)
• assertTimeout(Duration, Executable, String)

assertTimeoutPreemptively

public static void assertTimeoutPreemptively(Duration timeout,
 Executable executable,
 Supplier<@Nullable String> messageSupplier)

Assert that execution of the supplied executable completes before the given timeout is exceeded.

See the Preemptive Timeouts section of the class-level Javadoc for further details.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

See Also:

• assertTimeoutPreemptively(Duration, Executable)
• assertTimeoutPreemptively(Duration, Executable, String)
• assertTimeoutPreemptively(Duration, ThrowingSupplier)
• assertTimeoutPreemptively(Duration, ThrowingSupplier, String)
• assertTimeoutPreemptively(Duration, ThrowingSupplier, Supplier)
• assertTimeout(Duration, Executable, Supplier)

assertTimeoutPreemptively

public static <T extends @Nullable Object> T assertTimeoutPreemptively(Duration timeout,
 ThrowingSupplier<T> supplier)

Assert that execution of the supplied supplier completes before the given timeout is exceeded.

See the Preemptive Timeouts section of the class-level Javadoc for further details.

If the assertion passes then the supplier's result is returned.

See Also:

• assertTimeoutPreemptively(Duration, Executable)
• assertTimeoutPreemptively(Duration, Executable, String)
• assertTimeoutPreemptively(Duration, Executable, Supplier)
• assertTimeoutPreemptively(Duration, ThrowingSupplier, String)
• assertTimeoutPreemptively(Duration, ThrowingSupplier, Supplier)
• assertTimeout(Duration, Executable)

assertTimeoutPreemptively

public static <T extends @Nullable Object> T assertTimeoutPreemptively(Duration timeout,
 ThrowingSupplier<T> supplier,
 @Nullable String message)

Assert that execution of the supplied supplier completes before the given timeout is exceeded.

See the Preemptive Timeouts section of the class-level Javadoc for further details.

If the assertion passes then the supplier's result is returned.

Fails with the supplied failure message.

See Also:

• assertTimeoutPreemptively(Duration, Executable)
• assertTimeoutPreemptively(Duration, Executable, String)
• assertTimeoutPreemptively(Duration, Executable, Supplier)
• assertTimeoutPreemptively(Duration, ThrowingSupplier)
• assertTimeoutPreemptively(Duration, ThrowingSupplier, Supplier)
• assertTimeout(Duration, Executable, String)

assertTimeoutPreemptively

public static <T extends @Nullable Object> T assertTimeoutPreemptively(Duration timeout,
 ThrowingSupplier<T> supplier,
 Supplier<@Nullable String> messageSupplier)

Assert that execution of the supplied supplier completes before the given timeout is exceeded.

See the Preemptive Timeouts section of the class-level Javadoc for further details.

If the assertion passes then the supplier's result is returned.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

See Also:

• assertTimeoutPreemptively(Duration, Executable)
• assertTimeoutPreemptively(Duration, Executable, String)
• assertTimeoutPreemptively(Duration, Executable, Supplier)
• assertTimeoutPreemptively(Duration, ThrowingSupplier)
• assertTimeoutPreemptively(Duration, ThrowingSupplier, String)
• assertTimeout(Duration, Executable, Supplier)

assertInstanceOf

@API(status=STABLE,
     since="5.10")
@Contract("_, null -> fail")
public static <T> T assertInstanceOf(Class<T> expectedType,
 @Nullable Object actualValue)

Assert that the supplied actualValue is an instance of the expectedType.

Like the instanceof operator a null value is not considered to be of the expectedType and does not pass the assertion.

Since:

5.8

assertInstanceOf

@API(status=STABLE,
     since="5.10")
@Contract("_, null, _ -> fail")
public static <T> T assertInstanceOf(Class<T> expectedType,
 @Nullable Object actualValue,
 @Nullable String message)

Assert that the supplied actualValue is an instance of the expectedType.

Like the instanceof operator a null value is not considered to be of the expectedType and does not pass the assertion.

Fails with the supplied failure message.

Since:

5.8

assertInstanceOf

@Contract("_, null, _ -> fail")
@API(status=STABLE,
     since="5.10")
public static <T> T assertInstanceOf(Class<T> expectedType,
 @Nullable Object actualValue,
 Supplier<@Nullable String> messageSupplier)

Assert that the supplied actualValue is an instance of the expectedType.

Like the instanceof operator a null value is not considered to be of the expectedType and does not pass the assertion.

If necessary, the failure message will be retrieved lazily from the supplied messageSupplier.

Since:

5.8