Uses of Interface
org.assertj.core.api.AssertionInfo
Packages that use AssertionInfo
-
Uses of AssertionInfo in org.assertj.core.api
Classes in org.assertj.core.api that implement AssertionInfoModifier and TypeClassDescriptionclass
Writable information about an assertion.Methods in org.assertj.core.api with parameters of type AssertionInfoModifier and TypeMethodDescriptionprivate AssertionError
IterableAssert.actualDoesNotStartWithSequence
(AssertionInfo info, Iterable<?> actual, Object[] sequence) private AssertionError
ListAssert.actualDoesNotStartWithSequence
(AssertionInfo info, Object[] sequence) private static void
AbstractInstantAssert.assertNotNull
(AssertionInfo info, Instant actual) -
Uses of AssertionInfo in org.assertj.core.internal
Methods in org.assertj.core.internal with parameters of type AssertionInfoModifier and TypeMethodDescriptionprivate AssertionError
Iterables.actualContainsSubsequence
(AssertionInfo info, Iterable<?> actual, Object[] subsequence, int index) private AssertionError
Iterables.actualDoesContainSequence
(AssertionInfo info, Iterable<?> actual, Object[] sequence, int index) private AssertionError
Iterables.actualDoesNotContainSequence
(AssertionInfo info, Iterable<?> actual, Object[] sequence) private AssertionError
Iterables.actualDoesNotContainSubsequence
(AssertionInfo info, Iterable<?> actual, Object[] subsequence) private AssertionError
Iterables.actualDoesNotEndWithSequence
(AssertionInfo info, Iterable<?> actual, Object[] sequence) private AssertionError
Iterables.actualDoesNotStartWithSequence
(AssertionInfo info, Iterable<?> actual, Object[] sequence) private boolean
Dates.actualIsBetweenGivenPeriod
(AssertionInfo info, Date actual, Date start, Date end, boolean inclusiveStart, boolean inclusiveEnd) private boolean
Objects.actualIsExactlyInstanceOfType
(Object actual, Class<?> expectedType, AssertionInfo info) private AssertionError
Arrays.arrayDoesNotEndWithSequence
(AssertionInfo info, Failures failures, Object array, Object sequence) private AssertionError
Arrays.arrayDoesNotStartWithSequence
(AssertionInfo info, Failures failures, Object array, Object sequence) <E> void
Iterables.assertAllMatch
(AssertionInfo info, Iterable<? extends E> actual, Predicate<? super E> predicate, PredicateDescription predicateDescription) <E> void
Iterables.assertAllSatisfy
(AssertionInfo info, Iterable<? extends E> actual, Consumer<? super E> requirements) <E> void
Iterables.assertAnySatisfy
(AssertionInfo info, Iterable<? extends E> actual, Consumer<? super E> requirements) <E> void
Arrays.assertAre
(AssertionInfo info, Failures failures, Conditions conditions, Object array, Condition<E> condition) <T> void
Iterables.assertAre
(AssertionInfo info, Iterable<? extends T> actual, Condition<? super T> condition) Assert that each element of givenIterable
satisfies the given condition.<E> void
ObjectArrays.assertAre
(AssertionInfo info, E[] actual, Condition<? super E> condition) Assert that each element of given array satisfies the given condition.<E> void
Arrays.assertAreAtLeast
(AssertionInfo info, Failures failures, Conditions conditions, Object array, int times, Condition<E> condition) <E> void
Iterables.assertAreAtLeast
(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition) Assert that there are at least n elements in the actualIterable
satisfying the given condition.<E> void
ObjectArrays.assertAreAtLeast
(AssertionInfo info, E[] actual, int n, Condition<? super E> condition) Assert that there are at least n array elements satisfying the given condition.<E> void
Arrays.assertAreAtMost
(AssertionInfo info, Failures failures, Conditions conditions, Object array, int times, Condition<E> condition) <E> void
Iterables.assertAreAtMost
(AssertionInfo info, Iterable<? extends E> actual, int n, Condition<? super E> condition) Assert that there are at most n elements in the actualIterable
satisfying the given condition.<E> void
ObjectArrays.assertAreAtMost
(AssertionInfo info, E[] actual, int n, Condition<? super E> condition) Assert that there are at most n array elements satisfying the given condition.<E> void
Arrays.assertAreExactly
(AssertionInfo info, Failures failures, Conditions conditions, Object array, int times, Condition<E> condition) <E> void
Iterables.assertAreExactly
(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition) Verifies that there are exactly n elements in the actualIterable
satisfying the given condition.<E> void
ObjectArrays.assertAreExactly
(AssertionInfo info, E[] actual, int n, Condition<? super E> condition) Verifies that there are exactly n array elements satisfying the given condition.<E> void
Arrays.assertAreNot
(AssertionInfo info, Failures failures, Conditions conditions, Object array, Condition<E> condition) <E> void
Iterables.assertAreNot
(AssertionInfo info, Iterable<? extends E> actual, Condition<? super E> condition) Assert that each element of givenIterable
not satisfies the given condition.<E> void
ObjectArrays.assertAreNot
(AssertionInfo info, E[] actual, Condition<? super E> condition) Assert that each element of given array not satisfies the given condition.void
Strings.assertBlank
(AssertionInfo info, CharSequence actual) Asserts that the givenCharSequence
isNull
, empty or contains only whitespace.void
Files.assertCanRead
(AssertionInfo info, File actual) Asserts that the given file can be read by the application.void
Files.assertCanWrite
(AssertionInfo info, File actual) Asserts that the given file can be modified by the application.(package private) void
Arrays.assertContains
(AssertionInfo info, Failures failures, Object actual, Object values) (package private) void
Arrays.assertContains
(AssertionInfo info, Failures failures, Object array, Object value, Index index) void
BooleanArrays.assertContains
(AssertionInfo info, boolean[] actual, boolean[] values) Asserts that the given array contains the given values, in any order.void
BooleanArrays.assertContains
(AssertionInfo info, boolean[] actual, boolean value, Index index) Verifies that the given array contains the given value at the given index.void
ByteArrays.assertContains
(AssertionInfo info, byte[] actual, byte[] values) Asserts that the given array contains the given values, in any order.void
ByteArrays.assertContains
(AssertionInfo info, byte[] actual, byte value, Index index) Verifies that the given array contains the given value at the given index.void
ByteArrays.assertContains
(AssertionInfo info, byte[] actual, int[] values) Asserts that the given array contains the given values, in any order.void
ByteArrays.assertContains
(AssertionInfo info, byte[] actual, int value, Index index) Verifies that the given array contains the given value at the given index.void
CharArrays.assertContains
(AssertionInfo info, char[] actual, char[] values) Asserts that the given array contains the given values, in any order.void
CharArrays.assertContains
(AssertionInfo info, char[] actual, char value, Index index) Verifies that the given array contains the given value at the given index.void
DoubleArrays.assertContains
(AssertionInfo info, double[] actual, double[] values) Asserts that the given array contains the given values, in any order.void
DoubleArrays.assertContains
(AssertionInfo info, double[] actual, double value, Index index) Verifies that the given array contains the given value at the given index.void
FloatArrays.assertContains
(AssertionInfo info, float[] actual, float[] values) Asserts that the given array contains the given values, in any order.void
FloatArrays.assertContains
(AssertionInfo info, float[] actual, float value, Index index) Verifies that the given array contains the given value at the given index.void
IntArrays.assertContains
(AssertionInfo info, int[] actual, int[] values) Asserts that the given array contains the given values, in any order.void
IntArrays.assertContains
(AssertionInfo info, int[] actual, int value, Index index) Verifies that the given array contains the given value at the given index.void
Iterables.assertContains
(AssertionInfo info, Iterable<?> actual, Object[] values) Asserts that the givenIterable
contains the given values, in any order.void
Lists.assertContains
(AssertionInfo info, List<?> actual, Object value, Index index) Verifies that the givenList
contains the given object at the given index.void
LongArrays.assertContains
(AssertionInfo info, long[] actual, long[] values) Asserts that the given array contains the given values, in any order.void
LongArrays.assertContains
(AssertionInfo info, long[] actual, long value, Index index) Verifies that the given array contains the given value at the given index.<K,
V> void Maps.assertContains
(AssertionInfo info, Map<K, V> actual, Map.Entry<? extends K, ? extends V>[] entries) Asserts that the givenMap
contains the given entries, in any order.void
ObjectArrays.assertContains
(AssertionInfo info, Object[] actual, Object[] values) Asserts that the given array contains the given values, in any order.void
ObjectArrays.assertContains
(AssertionInfo info, Object[] actual, Object value, Index index) Verifies that the given array contains the given object at the given index.void
ShortArrays.assertContains
(AssertionInfo info, short[] actual, short[] values) Asserts that the given array contains the given values, in any order.void
ShortArrays.assertContains
(AssertionInfo info, short[] actual, short value, Index index) Verifies that the given array contains the given value at the given index.void
Strings.assertContains
(AssertionInfo info, CharSequence actual, CharSequence... values) Verifies that the givenCharSequence
contains the given strings.(package private) void
Arrays.assertcontainsAll
(AssertionInfo info, Failures failures, Object array, Iterable<?> iterable) void
Iterables.assertContainsAll
(AssertionInfo info, Iterable<?> actual, Iterable<?> other) Asserts that the givenIterable
contains all the elements of the otherIterable
, in any order.<E> void
ObjectArrays.assertContainsAll
(AssertionInfo info, E[] actual, Iterable<? extends E> other) Asserts that the given array contains all the elements of the givenIterable
, in any order.void
Classes.assertContainsAnnotations
(AssertionInfo info, Class<?> actual, Class<? extends Annotation>... annotations) Verifies that the actualClass
contains the givenAnnotation
s.<K,
V> void Maps.assertContainsAnyOf
(AssertionInfo info, Map<K, V> actual, Map.Entry<? extends K, ? extends V>[] entries) (package private) void
Arrays.assertContainsExactly
(AssertionInfo info, Failures failures, Object actual, Object values) void
BooleanArrays.assertContainsExactly
(AssertionInfo info, boolean[] actual, boolean[] values) void
ByteArrays.assertContainsExactly
(AssertionInfo info, byte[] actual, byte[] values) void
ByteArrays.assertContainsExactly
(AssertionInfo info, byte[] actual, int[] values) void
CharArrays.assertContainsExactly
(AssertionInfo info, char[] actual, char[] values) void
DoubleArrays.assertContainsExactly
(AssertionInfo info, double[] actual, double[] values) void
FloatArrays.assertContainsExactly
(AssertionInfo info, float[] actual, float[] values) void
IntArrays.assertContainsExactly
(AssertionInfo info, int[] actual, int[] values) void
Iterables.assertContainsExactly
(AssertionInfo info, Iterable<?> actual, Object[] values) Asserts that the givenIterable
contains exactly the given values and nothing else, in order.void
LongArrays.assertContainsExactly
(AssertionInfo info, long[] actual, long[] values) <K,
V> void Maps.assertContainsExactly
(AssertionInfo info, Map<K, V> actual, Map.Entry<? extends K, ? extends V>... entries) Verifies that the actual map contains only the given entries and nothing else, in order.
This assertion should only be used with map that have a consistent iteration order (i.e.void
ObjectArrays.assertContainsExactly
(AssertionInfo info, Object[] actual, Object[] values) void
ShortArrays.assertContainsExactly
(AssertionInfo info, short[] actual, short[] values) (package private) void
Arrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, Failures failures, Object actual, Object values) void
BooleanArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, boolean[] actual, boolean[] values) void
ByteArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, byte[] actual, byte[] values) void
ByteArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, byte[] actual, int[] values) void
CharArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, char[] actual, char[] values) void
DoubleArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, double[] actual, double[] values) void
FloatArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, float[] actual, float[] values) void
IntArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, int[] actual, int[] values) void
Iterables.assertContainsExactlyInAnyOrder
(AssertionInfo info, Iterable<?> actual, Object[] values) void
LongArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, long[] actual, long[] values) void
ObjectArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, Object[] actual, Object[] values) void
ShortArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, short[] actual, short[] values) void
Strings.assertContainsIgnoringCase
(AssertionInfo info, CharSequence actual, CharSequence sequence) Verifies that the givenCharSequence
contains the given sequence, ignoring case considerations.<K,
V> void Maps.assertContainsKeys
(AssertionInfo info, Map<K, V> actual, K... keys) Verifies that the actual map contain the given key.(package private) void
Arrays.assertContainsNull
(AssertionInfo info, Failures failures, Object array) void
Iterables.assertContainsNull
(AssertionInfo info, Iterable<?> actual) Asserts that the givenIterable
contains at least a null element.void
ObjectArrays.assertContainsNull
(AssertionInfo info, Object[] actual) Asserts that the given array contains at least a null element.(package private) void
Arrays.assertContainsOnly
(AssertionInfo info, Failures failures, Object actual, Object values) void
BooleanArrays.assertContainsOnly
(AssertionInfo info, boolean[] actual, boolean[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
ByteArrays.assertContainsOnly
(AssertionInfo info, byte[] actual, byte[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
ByteArrays.assertContainsOnly
(AssertionInfo info, byte[] actual, int[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
CharArrays.assertContainsOnly
(AssertionInfo info, char[] actual, char[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
DoubleArrays.assertContainsOnly
(AssertionInfo info, double[] actual, double[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
FloatArrays.assertContainsOnly
(AssertionInfo info, float[] actual, float[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
IntArrays.assertContainsOnly
(AssertionInfo info, int[] actual, int[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
Iterables.assertContainsOnly
(AssertionInfo info, Iterable<?> actual, Object[] values) Asserts that the givenIterable
contains only the given values and nothing else, in any order.void
LongArrays.assertContainsOnly
(AssertionInfo info, long[] actual, long[] values) Asserts that the given array contains only the given values and nothing else, in any order.<K,
V> void Maps.assertContainsOnly
(AssertionInfo info, Map<K, V> actual, Map.Entry<? extends K, ? extends V>... entries) Verifies that the actual map contains only the given entries and nothing else, in any order.void
ObjectArrays.assertContainsOnly
(AssertionInfo info, Object[] actual, Object[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
ShortArrays.assertContainsOnly
(AssertionInfo info, short[] actual, short[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
Strings.assertContainsOnlyDigits
(AssertionInfo info, CharSequence actual) Verifies that the givenCharSequence
contains only digits.<K,
V> void Maps.assertContainsOnlyKeys
(AssertionInfo info, Map<K, V> actual, K... keys) Verifies that the actual map contains only the given keys and nothing else, in any order.(package private) void
Arrays.assertContainsOnlyOnce
(AssertionInfo info, Failures failures, Object actual, Object values) void
BooleanArrays.assertContainsOnlyOnce
(AssertionInfo info, boolean[] actual, boolean[] values) Asserts that the given array contains only once the given values.void
ByteArrays.assertContainsOnlyOnce
(AssertionInfo info, byte[] actual, byte[] values) Asserts that the given array contains only once the given values.void
ByteArrays.assertContainsOnlyOnce
(AssertionInfo info, byte[] actual, int[] values) Asserts that the given array contains only once the given values.void
CharArrays.assertContainsOnlyOnce
(AssertionInfo info, char[] actual, char[] values) Asserts that the given array contains only once the given values.void
DoubleArrays.assertContainsOnlyOnce
(AssertionInfo info, double[] actual, double[] values) Asserts that the given array contains only once the given values.void
FloatArrays.assertContainsOnlyOnce
(AssertionInfo info, float[] actual, float[] values) Asserts that the given array contains only once the given values.void
IntArrays.assertContainsOnlyOnce
(AssertionInfo info, int[] actual, int[] values) Asserts that the given array contains only once the given values.void
Iterables.assertContainsOnlyOnce
(AssertionInfo info, Iterable<?> actual, Object[] values) Asserts that the givenIterable
contains the given values and only once.void
LongArrays.assertContainsOnlyOnce
(AssertionInfo info, long[] actual, long[] values) Asserts that the given array contains only once the given values.void
ObjectArrays.assertContainsOnlyOnce
(AssertionInfo info, Object[] actual, Object[] values) Asserts that the given array contains only once the given values.void
ShortArrays.assertContainsOnlyOnce
(AssertionInfo info, short[] actual, short[] values) Asserts that the given array contains only once the given values.void
Strings.assertContainsOnlyOnce
(AssertionInfo info, CharSequence actual, CharSequence sequence) Verifies that actualCharSequence
s contains only once the given sequence.void
Strings.assertContainsPattern
(AssertionInfo info, CharSequence actual, CharSequence regex) Verifies that the givenCharSequence
contains the given regular expression.void
Strings.assertContainsPattern
(AssertionInfo info, CharSequence actual, Pattern pattern) Verifies that the givenCharSequence
contains the given regular expression.(package private) void
Arrays.assertContainsSequence
(AssertionInfo info, Failures failures, Object actual, Object sequence) void
BooleanArrays.assertContainsSequence
(AssertionInfo info, boolean[] actual, boolean[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
ByteArrays.assertContainsSequence
(AssertionInfo info, byte[] actual, byte[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
ByteArrays.assertContainsSequence
(AssertionInfo info, byte[] actual, int[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
CharArrays.assertContainsSequence
(AssertionInfo info, char[] actual, char[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
DoubleArrays.assertContainsSequence
(AssertionInfo info, double[] actual, double[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
FloatArrays.assertContainsSequence
(AssertionInfo info, float[] actual, float[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
IntArrays.assertContainsSequence
(AssertionInfo info, int[] actual, int[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
Iterables.assertContainsSequence
(AssertionInfo info, Iterable<?> actual, Object[] sequence) Verifies that the given
contains the given sequence of objects, without any other objects between them.Iterable
void
LongArrays.assertContainsSequence
(AssertionInfo info, long[] actual, long[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
ObjectArrays.assertContainsSequence
(AssertionInfo info, Object[] actual, Object[] sequence) Verifies that the given array contains the given sequence of objects, without any other objects between them.void
ShortArrays.assertContainsSequence
(AssertionInfo info, short[] actual, short[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
Strings.assertContainsSequence
(AssertionInfo info, CharSequence actual, CharSequence[] sequence) (package private) void
Arrays.assertContainsSubsequence
(AssertionInfo info, Failures failures, Object actual, Object subsequence) void
BooleanArrays.assertContainsSubsequence
(AssertionInfo info, boolean[] actual, boolean[] subsequence) Verifies that the given array contains the given subsequence of values (possibly with other values between them).void
ByteArrays.assertContainsSubsequence
(AssertionInfo info, byte[] actual, byte[] subsequence) Verifies that the given array contains the given sequence of values (possibly with other values between them).void
ByteArrays.assertContainsSubsequence
(AssertionInfo info, byte[] actual, int[] subsequence) Verifies that the given array contains the given sequence of values (possibly with other values between them).void
CharArrays.assertContainsSubsequence
(AssertionInfo info, char[] actual, char[] subsequence) Verifies that the given array contains the given subsequence of values (possibly with other values between them).void
DoubleArrays.assertContainsSubsequence
(AssertionInfo info, double[] actual, double[] subsequence) Verifies that the given array contains the given subsequence of values (possibly with other values between them).void
FloatArrays.assertContainsSubsequence
(AssertionInfo info, float[] actual, float[] subsequence) Verifies that the given array contains the given subsequence of values (possibly with other values between them).void
IntArrays.assertContainsSubsequence
(AssertionInfo info, int[] actual, int[] subsequence) Verifies that the given array contains the given subsequence of values (possibly with other values between them).void
Iterables.assertContainsSubsequence
(AssertionInfo info, Iterable<?> actual, Object[] subsequence) Verifies that the given
contains the given subsequence of objects (possibly with other values between them).Iterable
void
Iterables.assertContainsSubsequence
(AssertionInfo info, Iterable<?> actual, List<?> subsequence) void
LongArrays.assertContainsSubsequence
(AssertionInfo info, long[] actual, long[] subsequence) Verifies that the given array contains the given subsequence of values (possibly with other values between them).void
ObjectArrays.assertContainsSubsequence
(AssertionInfo info, Object[] actual, Object[] subsequence) Verifies that the given array contains the given subsequence of objects (possibly with other values between them).void
ShortArrays.assertContainsSubsequence
(AssertionInfo info, short[] actual, short[] subsequence) Verifies that the given array contains the given subsequence of values (possibly with other values between them).<K,
V> void Maps.assertContainsValue
(AssertionInfo info, Map<K, V> actual, V value) Verifies that the actual map contain the given value.<K,
V> void Maps.assertContainsValues
(AssertionInfo info, Map<K, V> actual, V... values) Verifies that the actual map contain the given values.(package private) void
Arrays.assertDoesNotContain
(AssertionInfo info, Failures failures, Object array, Object values) (package private) void
Arrays.assertDoesNotContain
(AssertionInfo info, Failures failures, Object array, Object value, Index index) void
BooleanArrays.assertDoesNotContain
(AssertionInfo info, boolean[] actual, boolean[] values) Asserts that the given array does not contain the given values.void
BooleanArrays.assertDoesNotContain
(AssertionInfo info, boolean[] actual, boolean value, Index index) Verifies that the given array does not contain the given value at the given index.void
ByteArrays.assertDoesNotContain
(AssertionInfo info, byte[] actual, byte[] values) Asserts that the given array does not contain the given values.void
ByteArrays.assertDoesNotContain
(AssertionInfo info, byte[] actual, byte value, Index index) Verifies that the given array does not contain the given value at the given index.void
ByteArrays.assertDoesNotContain
(AssertionInfo info, byte[] actual, int[] values) Asserts that the given array does not contain the given values.void
ByteArrays.assertDoesNotContain
(AssertionInfo info, byte[] actual, int value, Index index) Verifies that the given array does not contain the given value at the given index.void
CharArrays.assertDoesNotContain
(AssertionInfo info, char[] actual, char[] values) Asserts that the given array does not contain the given values.void
CharArrays.assertDoesNotContain
(AssertionInfo info, char[] actual, char value, Index index) Verifies that the given array does not contain the given value at the given index.void
DoubleArrays.assertDoesNotContain
(AssertionInfo info, double[] actual, double[] values) Asserts that the given array does not contain the given values.void
DoubleArrays.assertDoesNotContain
(AssertionInfo info, double[] actual, double value, Index index) Verifies that the given array does not contain the given value at the given index.void
FloatArrays.assertDoesNotContain
(AssertionInfo info, float[] actual, float[] values) Asserts that the given array does not contain the given values.void
FloatArrays.assertDoesNotContain
(AssertionInfo info, float[] actual, float value, Index index) Verifies that the given array does not contain the given value at the given index.void
IntArrays.assertDoesNotContain
(AssertionInfo info, int[] actual, int[] values) Asserts that the given array does not contain the given values.void
IntArrays.assertDoesNotContain
(AssertionInfo info, int[] actual, int value, Index index) Verifies that the given array does not contain the given value at the given index.void
Iterables.assertDoesNotContain
(AssertionInfo info, Iterable<?> actual, Object[] values) Asserts that the givenIterable
does not contain the given values.void
Lists.assertDoesNotContain
(AssertionInfo info, List<?> actual, Object value, Index index) Verifies that the givenList
does not contain the given object at the given index.void
LongArrays.assertDoesNotContain
(AssertionInfo info, long[] actual, long[] values) Asserts that the given array does not contain the given values.void
LongArrays.assertDoesNotContain
(AssertionInfo info, long[] actual, long value, Index index) Verifies that the given array does not contain the given value at the given index.<K,
V> void Maps.assertDoesNotContain
(AssertionInfo info, Map<K, V> actual, Map.Entry<? extends K, ? extends V>[] entries) Asserts that the givenMap
does not contain the given entries.void
ObjectArrays.assertDoesNotContain
(AssertionInfo info, Object[] actual, Object[] values) Asserts that the given array does not contain the given values.void
ObjectArrays.assertDoesNotContain
(AssertionInfo info, Object[] actual, Object value, Index index) Verifies that the given array does not contain the given object at the given index.void
ShortArrays.assertDoesNotContain
(AssertionInfo info, short[] actual, short[] values) Asserts that the given array does not contain the given values.void
ShortArrays.assertDoesNotContain
(AssertionInfo info, short[] actual, short value, Index index) Verifies that the given array does not contain the given value at the given index.void
Strings.assertDoesNotContain
(AssertionInfo info, CharSequence actual, CharSequence sequence) Verifies that the givenCharSequence
does not contain the given sequence.<T> void
Iterables.assertDoesNotContainAnyElementsOf
(AssertionInfo info, Iterable<? extends T> actual, Iterable<? extends T> iterable) Asserts that the givenIterable
does not contain the given values.<T> void
ObjectArrays.assertDoesNotContainAnyElementsOf
(AssertionInfo info, Object[] actual, Iterable<? extends T> iterable) <K,
V> void Maps.assertDoesNotContainKey
(AssertionInfo info, Map<K, V> actual, K key) Verifies that the actual map not contains the given key.<K,
V> void Maps.assertDoesNotContainKeys
(AssertionInfo info, Map<K, V> actual, K... keys) Verifies that the actual map not contains all the given keys.(package private) void
Arrays.assertDoesNotContainNull
(AssertionInfo info, Failures failures, Object array) void
Iterables.assertDoesNotContainNull
(AssertionInfo info, Iterable<?> actual) Asserts that the givenIterable
does not contain null elements.void
ObjectArrays.assertDoesNotContainNull
(AssertionInfo info, Object[] actual) Asserts that the given array does not contain null elements.void
Strings.assertDoesNotContainPattern
(AssertionInfo info, CharSequence actual, CharSequence regex) Verifies that the givenCharSequence
does not contain the given regular expression.void
Strings.assertDoesNotContainPattern
(AssertionInfo info, CharSequence actual, Pattern pattern) Verifies that the givenCharSequence
does not contain the given regular expression.(package private) void
Arrays.assertDoesNotContainSequence
(AssertionInfo info, Failures failures, Object actual, Object sequence) void
Iterables.assertDoesNotContainSequence
(AssertionInfo info, Iterable<?> actual, Object[] sequence) Verifies that the given
does not contain the given sequence of objects in order.Iterable
void
ObjectArrays.assertDoesNotContainSequence
(AssertionInfo info, Object[] actual, Object[] sequence) Verifies that the given array does not contain the given sequence of objects in order.(package private) void
Arrays.assertDoesNotContainSubsequence
(AssertionInfo info, Failures failures, Object actual, Object subsequence) void
Iterables.assertDoesNotContainSubsequence
(AssertionInfo info, Iterable<?> actual, Object[] subsequence) Verifies that the given
does not contain the given subsequence of objects (possibly with other values between them).Iterable
void
ObjectArrays.assertDoesNotContainSubsequence
(AssertionInfo info, Object[] actual, Object[] subsequence) Verifies that the given array does not contain the given subsequence of objects (possibly with other values between them).<K,
V> void Maps.assertDoesNotContainValue
(AssertionInfo info, Map<K, V> actual, V value) Verifies that the actual map not contains the given value.void
Strings.assertDoesNotEndWith
(AssertionInfo info, CharSequence actual, CharSequence suffix) Verifies that the givenCharSequence
does not end with the given suffix.void
Files.assertDoesNotExist
(AssertionInfo info, File actual) Asserts that the given file does not exist.void
Paths.assertDoesNotExist
(AssertionInfo info, Path actual) <T> void
Conditions.assertDoesNotHave
(AssertionInfo info, T actual, Condition<? super T> condition) Asserts that the actual value does not satisfy the given
.Condition
(package private) void
Arrays.assertDoesNotHaveDuplicates
(AssertionInfo info, Failures failures, Object array) void
BooleanArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, boolean[] actual) Asserts that the given array does not have duplicate values.void
ByteArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, byte[] actual) Asserts that the given array does not have duplicate values.void
CharArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, char[] actual) Asserts that the given array does not have duplicate values.void
DoubleArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, double[] actual) Asserts that the given array does not have duplicate values.void
FloatArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, float[] actual) Asserts that the given array does not have duplicate values.void
IntArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, int[] actual) Asserts that the given array does not have duplicate values.void
Iterables.assertDoesNotHaveDuplicates
(AssertionInfo info, Iterable<?> actual) Asserts that the givenIterable
does not have duplicate values.void
LongArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, long[] actual) Asserts that the given array does not have duplicate values.void
ObjectArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, Object[] actual) Asserts that the given array does not have duplicate values.void
ShortArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, short[] actual) Asserts that the given array does not have duplicate values.void
Objects.assertDoesNotHaveSameClassAs
(AssertionInfo info, Object actual, Object other) Verifies that the actual value does not have the same class as the given object.void
Strings.assertDoesNotMatch
(AssertionInfo info, CharSequence actual, CharSequence regex) Verifies that the givenCharSequence
does not match the given regular expression.void
Strings.assertDoesNotMatch
(AssertionInfo info, CharSequence actual, Pattern pattern) Verifies that the givenCharSequence
does not match the given regular expression.void
Strings.assertDoesNotStartWith
(AssertionInfo info, CharSequence actual, CharSequence prefix) Verifies that the givenCharSequence
does not start with the given prefix.<E> void
Iterables.assertDoNotHave
(AssertionInfo info, Iterable<? extends E> actual, Condition<? super E> condition) Assert that each element of givenIterable
not satisfies the given condition.<E> void
ObjectArrays.assertDoNotHave
(AssertionInfo info, E[] actual, Condition<? super E> condition) Assert that each element of given array not satisfies the given condition.(package private) void
Arrays.assertEmpty
(AssertionInfo info, Failures failures, Object array) void
BooleanArrays.assertEmpty
(AssertionInfo info, boolean[] actual) Asserts that the given array is empty.void
ByteArrays.assertEmpty
(AssertionInfo info, byte[] actual) Asserts that the given array is empty.void
CharArrays.assertEmpty
(AssertionInfo info, char[] actual) Asserts that the given array is empty.void
DoubleArrays.assertEmpty
(AssertionInfo info, double[] actual) Asserts that the given array is empty.void
FloatArrays.assertEmpty
(AssertionInfo info, float[] actual) Asserts that the given array is empty.void
IntArrays.assertEmpty
(AssertionInfo info, int[] actual) Asserts that the given array is empty.void
Iterables.assertEmpty
(AssertionInfo info, Iterable<?> actual) Asserts that the givenIterable
is empty.void
LongArrays.assertEmpty
(AssertionInfo info, long[] actual) Asserts that the given array is empty.void
Maps.assertEmpty
(AssertionInfo info, Map<?, ?> actual) Asserts that the givenMap
is empty.void
ObjectArrays.assertEmpty
(AssertionInfo info, Object[] actual) Asserts that the given array is empty.void
ShortArrays.assertEmpty
(AssertionInfo info, short[] actual) Asserts that the given array is empty.void
Strings.assertEmpty
(AssertionInfo info, CharSequence actual) Asserts that the givenCharSequence
is empty.(package private) void
Arrays.assertEndsWith
(AssertionInfo info, Failures failures, Object actual, Object sequence) void
BooleanArrays.assertEndsWith
(AssertionInfo info, boolean[] actual, boolean[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
ByteArrays.assertEndsWith
(AssertionInfo info, byte[] actual, byte[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
ByteArrays.assertEndsWith
(AssertionInfo info, byte[] actual, int[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
CharArrays.assertEndsWith
(AssertionInfo info, char[] actual, char[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
DoubleArrays.assertEndsWith
(AssertionInfo info, double[] actual, double[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
FloatArrays.assertEndsWith
(AssertionInfo info, float[] actual, float[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
IntArrays.assertEndsWith
(AssertionInfo info, int[] actual, int[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
Iterables.assertEndsWith
(AssertionInfo info, Iterable<?> actual, Object[] sequence) Verifies that the givenIterable
ends with the given sequence of objects, without any other objects between them.void
LongArrays.assertEndsWith
(AssertionInfo info, long[] actual, long[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
ObjectArrays.assertEndsWith
(AssertionInfo info, Object[] actual, Object[] sequence) Verifies that the given array ends with the given sequence of objects, without any other objects between them.void
Paths.assertEndsWith
(AssertionInfo info, Path actual, Path end) void
ShortArrays.assertEndsWith
(AssertionInfo info, short[] actual, short[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
Strings.assertEndsWith
(AssertionInfo info, CharSequence actual, CharSequence suffix) Verifies that the givenCharSequence
ends with the given suffix.void
Paths.assertEndsWithRaw
(AssertionInfo info, Path actual, Path end) void
Booleans.assertEqual
(AssertionInfo info, Boolean actual, boolean expected) Asserts that two booleans are equal.<T> void
Comparables.assertEqual
(AssertionInfo info, T actual, T expected) Asserts that two T instances are equal.void
Objects.assertEqual
(AssertionInfo info, Object actual, Object expected) Asserts that two objects are equal.void
RealNumbers.assertEqual
(AssertionInfo info, NUMBER actual, NUMBER expected, Offset<NUMBER> offset) Verifies that two real numbers are equal within a positive offset.
It does not rely on the custom comparisonStrategy (if one is set) because using an offset is already a specific comparison strategy.<T extends Comparable<? super T>>
voidComparables.assertEqualByComparison
(AssertionInfo info, T actual, T expected) Asserts that two
s are equal by invokingComparable
.Comparable.compareTo(Object)
Note that it does not rely on the customComparables.comparisonStrategy
if one has been set.void
Strings.assertEqualsIgnoringCase
(AssertionInfo info, CharSequence actual, CharSequence expected) Verifies that twoCharSequence
s are equal, ignoring case considerations.void
Strings.assertEqualsIgnoringWhitespace
(AssertionInfo info, CharSequence actual, CharSequence expected) Verifies that twoCharSequence
s are equal, ignoring any differences in whitespace.void
Strings.assertEqualsNormalizingWhitespace
(AssertionInfo info, CharSequence actual, CharSequence expected) Verifies that twoCharSequence
s are equal, after the whitespace of both strings has been normalized.void
Files.assertExists
(AssertionInfo info, File actual) Asserts that the given file exists, regardless it's a file or directory.void
Paths.assertExists
(AssertionInfo info, Path actual) void
Paths.assertExistsNoFollowLinks
(AssertionInfo info, Path actual) <T extends Comparable<? super T>>
voidComparables.assertGreaterThan
(AssertionInfo info, T actual, T other) Asserts that the actual value is greater than the other one.<T extends Comparable<? super T>>
voidComparables.assertGreaterThanOrEqualTo
(AssertionInfo info, T actual, T other) Asserts that the actual value is greater than or equal to the other one.<T> void
Conditions.assertHas
(AssertionInfo info, T actual, Condition<? super T> condition) Asserts that the actual value satisfies the given
.Condition
<T> void
Lists.assertHas
(AssertionInfo info, List<? extends T> actual, Condition<? super T> condition, Index index) Verifies that the givenList
satisfies the given
at the given index.Condition
void
Urls.assertHasAnchor
(AssertionInfo info, URL actual, String expected) <E> void
ObjectArrays.assertHasAtLeastOneElementOfType
(AssertionInfo info, E[] actual, Class<?> type) void
Uris.assertHasAuthority
(AssertionInfo info, URI actual, String expected) void
Urls.assertHasAuthority
(AssertionInfo info, URL actual, String expected) void
Files.assertHasBinaryContent
(AssertionInfo info, File actual, byte[] expected) Asserts that the given file has the given binary content.void
Paths.assertHasBinaryContent
(AssertionInfo info, Path actual, byte[] expected) void
Throwables.assertHasCause
(AssertionInfo info, Throwable actual, Throwable expectedCause) void
Throwables.assertHasCauseExactlyInstanceOf
(AssertionInfo info, Throwable actual, Class<? extends Throwable> type) Assert that the cause of actualThrowable
is exactly an instance of the given type.void
Throwables.assertHasCauseInstanceOf
(AssertionInfo info, Throwable actual, Class<? extends Throwable> type) Assert that the cause of actualThrowable
is an instance of the given type.void
Files.assertHasContent
(AssertionInfo info, File actual, String expected, Charset charset) Asserts that the given file has the given text content.void
Paths.assertHasContent
(AssertionInfo info, Path actual, String expected, Charset charset) void
Dates.assertHasDayOfMonth
(AssertionInfo info, Date actual, int dayOfMonth) Verifies that the actualDate
day of month is equal to the given day of month.void
Dates.assertHasDayOfWeek
(AssertionInfo info, Date actual, int dayOfWeek) Verifies that the actualDate
day of week is equal to the given day of week.void
Classes.assertHasDeclaredFields
(AssertionInfo info, Class<?> actual, String... fields) Verifies that the actualClass
has the declaredfields
.void
Classes.assertHasDeclaredMethods
(AssertionInfo info, Class<?> actual, String... methods) Verifies that the actualClass
has the declaredmethods
.<K,
V> void Maps.assertHasEntrySatisfying
(AssertionInfo info, Map<K, V> actual, K key, Consumer<? super V> valueRequirements) Verifies that theMap
contains the value for givenkey
that satisfy givenvalueRequirements
.<K,
V> void Maps.assertHasEntrySatisfying
(AssertionInfo info, Map<K, V> actual, K key, Condition<? super V> valueCondition) Verifies that the givenMap
contains the value for givenkey
that satisfy givenvalueCondition
.<K,
V> void Maps.assertHasEntrySatisfying
(AssertionInfo info, Map<K, V> actual, Condition<? super Map.Entry<K, V>> entryCondition) Verifies that the givenMap
contains an entry satisfying givenentryCondition
.<K,
V> void Maps.assertHasEntrySatisfyingConditions
(AssertionInfo info, Map<K, V> actual, Condition<? super K> keyCondition, Condition<? super V> valueCondition) Verifies that the givenMap
contains an entry with key satisfyingkeyCondition
and value satisfyingvalueCondition
.void
Files.assertHasExtension
(AssertionInfo info, File actual, String expected) Asserts that the givenFile
has the given extension.<A> void
Objects.assertHasFieldOrProperty
(AssertionInfo info, A actual, String name) <A> void
Objects.assertHasFieldOrPropertyWithValue
(AssertionInfo info, A actual, String name, Object expectedValue) void
Paths.assertHasFileName
(AssertionInfo info, Path actual, String fileName) void
Uris.assertHasFragment
(AssertionInfo info, URI actual, String expected) void
Uris.assertHasHost
(AssertionInfo info, URI actual, String expected) void
Urls.assertHasHost
(AssertionInfo info, URL actual, String expected) void
Dates.assertHasHourOfDay
(AssertionInfo info, Date actual, int hourOfDay) Verifies that the actualDate
hour od day is equal to the given hour of day (24-hour clock).<K> void
Maps.assertHasKeySatisfying
(AssertionInfo info, Map<K, ?> actual, Condition<? super K> keyCondition) Verifies that the givenMap
contains an entry with key satisfyingkeyCondition
.void
Strings.assertHasLineCount
(AssertionInfo info, CharSequence actual, int expectedLineCount) Asserts that the line count of the givenCharSequence
is equal to the expected one.void
Throwables.assertHasMessage
(AssertionInfo info, Throwable actual, String message) Asserts that the given actualThrowable
message is equal to the given one.void
Throwables.assertHasMessageContaining
(AssertionInfo info, Throwable actual, String description) Asserts that the message of the actualThrowable
contains with the given description.void
Throwables.assertHasMessageEndingWith
(AssertionInfo info, Throwable actual, String description) Asserts that the message of the actualThrowable
ends with the given description.void
Throwables.assertHasMessageMatching
(AssertionInfo info, Throwable actual, String regex) Asserts that the message of the actualThrowable
matches with the given regular expression.void
Throwables.assertHasMessageStartingWith
(AssertionInfo info, Throwable actual, String description) Asserts that the message of the actualThrowable
starts with the given description.void
Classes.assertHasMethods
(AssertionInfo info, Class<?> actual, String... methods) Verifies that the actualClass
has themethods
.void
Dates.assertHasMillisecond
(AssertionInfo info, Date actual, int millisecond) Verifies that the actualDate
millisecond is equal to the given millisecond.void
Dates.assertHasMinute
(AssertionInfo info, Date actual, int minute) Verifies that the actualDate
minute is equal to the given minute.void
Dates.assertHasMonth
(AssertionInfo info, Date actual, int month) Verifies that the actualDate
month is equal to the given month, month value starting at 1 (January=1, February=2, ...).void
Files.assertHasName
(AssertionInfo info, File actual, String expected) Asserts that the givenFile
has the given name.void
Throwables.assertHasNoCause
(AssertionInfo info, Throwable actual) Asserts that the actualThrowable
does not have a cause.<A> void
Objects.assertHasNoNullFieldsOrPropertiesExcept
(AssertionInfo info, A actual, String... propertiesOrFieldsToIgnore) Assert that the given object has no null fields except the given ones.void
Uris.assertHasNoParameter
(AssertionInfo info, URI actual, String name) void
Uris.assertHasNoParameter
(AssertionInfo info, URI actual, String name, String unwantedValue) void
Urls.assertHasNoParameter
(AssertionInfo info, URL actual, String name) void
Urls.assertHasNoParameter
(AssertionInfo info, URL actual, String name, String unwantedValue) void
Uris.assertHasNoParameters
(AssertionInfo info, URI actual) void
Urls.assertHasNoParameters
(AssertionInfo info, URL actual) void
Files.assertHasNoParent
(AssertionInfo info, File actual) Asserts that the givenFile
does not have a parent.void
Paths.assertHasNoParent
(AssertionInfo info, Path actual) void
Paths.assertHasNoParentRaw
(AssertionInfo info, Path actual) void
Throwables.assertHasNoSuppressedExceptions
(AssertionInfo info, Throwable actual) void
Classes.assertHasOnlyDeclaredFields
(AssertionInfo info, Class<?> actual, String... expectedFields) Verifies that the actualClass
has the exactly thefields
and nothing more.<E> void
ObjectArrays.assertHasOnlyElementsOfType
(AssertionInfo info, E[] actual, Class<?> type) (package private) void
Arrays.assertHasOnlyElementsOfTypes
(AssertionInfo info, Failures failures, Object actual, Class<?>[] expectedTypes) <E> void
ObjectArrays.assertHasOnlyElementsOfTypes
(AssertionInfo info, E[] actual, Class<?>... types) void
Classes.assertHasOnlyPublicFields
(AssertionInfo info, Class<?> actual, String... expectedFields) Verifies that the actualClass
has only thefields
and nothing more.void
Uris.assertHasParameter
(AssertionInfo info, URI actual, String name) void
Uris.assertHasParameter
(AssertionInfo info, URI actual, String expectedParameterName, String expectedParameterValue) void
Urls.assertHasParameter
(AssertionInfo info, URL actual, String name) void
Urls.assertHasParameter
(AssertionInfo info, URL actual, String expectedParameterName, String expectedParameterValue) void
Files.assertHasParent
(AssertionInfo info, File actual, File expected) Asserts that the givenFile
has the given parent.void
Paths.assertHasParent
(AssertionInfo info, Path actual, Path expected) void
Paths.assertHasParentRaw
(AssertionInfo info, Path actual, Path expected) void
Uris.assertHasPath
(AssertionInfo info, URI actual, String path) void
Urls.assertHasPath
(AssertionInfo info, URL actual, String path) void
Uris.assertHasPort
(AssertionInfo info, URI actual, Integer expected) void
Urls.assertHasPort
(AssertionInfo info, URL actual, int expected) void
Urls.assertHasProtocol
(AssertionInfo info, URL actual, String protocol) void
Classes.assertHasPublicFields
(AssertionInfo info, Class<?> actual, String... fields) Verifies that the actualClass
has thefields
.void
Classes.assertHasPublicMethods
(AssertionInfo info, Class<?> actual, String... methods) Verifies that the actualClass
has the publicmethods
.void
Uris.assertHasQuery
(AssertionInfo info, URI actual, String expected) void
Urls.assertHasQuery
(AssertionInfo info, URL actual, String expected) void
Throwables.assertHasRootCauseExactlyInstanceOf
(AssertionInfo info, Throwable actual, Class<? extends Throwable> type) Assert that the root cause of actualThrowable
is exactly an instance of the given type.void
Throwables.assertHasRootCauseInstanceOf
(AssertionInfo info, Throwable actual, Class<? extends Throwable> type) Assert that the root cause of actualThrowable
is an instance of the given type.void
Objects.assertHasSameClassAs
(AssertionInfo info, Object actual, Object other) Verifies that the actual value has the same class as the given object.void
Paths.assertHasSameContentAs
(AssertionInfo info, Path actual, Charset actualCharset, Path expected, Charset expectedCharset) (package private) void
Arrays.assertHasSameSizeAs
(AssertionInfo info, Object array, Iterable<?> other) void
Arrays.assertHasSameSizeAs
(AssertionInfo info, Object array, Object other) void
BooleanArrays.assertHasSameSizeAs
(AssertionInfo info, boolean[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
BooleanArrays.assertHasSameSizeAs
(AssertionInfo info, boolean[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
ByteArrays.assertHasSameSizeAs
(AssertionInfo info, byte[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
CharArrays.assertHasSameSizeAs
(AssertionInfo info, char[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
CharArrays.assertHasSameSizeAs
(AssertionInfo info, char[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
DoubleArrays.assertHasSameSizeAs
(AssertionInfo info, double[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
DoubleArrays.assertHasSameSizeAs
(AssertionInfo info, double[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
FloatArrays.assertHasSameSizeAs
(AssertionInfo info, float[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
FloatArrays.assertHasSameSizeAs
(AssertionInfo info, float[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
IntArrays.assertHasSameSizeAs
(AssertionInfo info, int[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
IntArrays.assertHasSameSizeAs
(AssertionInfo info, int[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
Iterables.assertHasSameSizeAs
(AssertionInfo info, Iterable<?> actual, Iterable<?> other) Assert that the actualIterable
has the same size as the otherIterable
.void
Iterables.assertHasSameSizeAs
(AssertionInfo info, Iterable<?> actual, Object other) Assert that the actualIterable
has the same size as the other array.void
LongArrays.assertHasSameSizeAs
(AssertionInfo info, long[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
LongArrays.assertHasSameSizeAs
(AssertionInfo info, long[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
Maps.assertHasSameSizeAs
(AssertionInfo info, Map<?, ?> map, Iterable<?> other) Asserts that the number of entries in the givenMap
has the same size as the otherIterable
.void
Maps.assertHasSameSizeAs
(AssertionInfo info, Map<?, ?> map, Object other) Asserts that the number of entries in the givenMap
has the same size as the other array.void
Maps.assertHasSameSizeAs
(AssertionInfo info, Map<?, ?> map, Map<?, ?> other) Asserts that the size of the givenMap
is equal to the size of the otherMap
.void
ObjectArrays.assertHasSameSizeAs
(AssertionInfo info, Object[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
ObjectArrays.assertHasSameSizeAs
(AssertionInfo info, Object[] actual, Object other) Assert that the actual array has the same size as the other array.void
ShortArrays.assertHasSameSizeAs
(AssertionInfo info, short[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
ShortArrays.assertHasSameSizeAs
(AssertionInfo info, short[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
Strings.assertHasSameSizeAs
(AssertionInfo info, CharSequence actual, CharSequence other) void
Strings.assertHasSameSizeAs
(AssertionInfo info, CharSequence actual, Iterable<?> other) Asserts that the number of entries in the givenCharSequence
has the same size as the otherIterable
.void
Strings.assertHasSameSizeAs
(AssertionInfo info, CharSequence actual, Object array) Asserts that the number of entries in the givenCharSequence
has the same size as the other array.void
Dates.assertHasSameTime
(AssertionInfo info, Date actual, Date expected) Verifies that the actualDate
has same time as the givenDate
.void
Uris.assertHasScheme
(AssertionInfo info, URI actual, String scheme) void
Dates.assertHasSecond
(AssertionInfo info, Date actual, int second) Verifies that the actualDate
second is equal to the given second.(package private) void
Arrays.assertHasSize
(AssertionInfo info, Failures failures, Object array, int expectedSize) void
BooleanArrays.assertHasSize
(AssertionInfo info, boolean[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
ByteArrays.assertHasSize
(AssertionInfo info, byte[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
CharArrays.assertHasSize
(AssertionInfo info, char[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
DoubleArrays.assertHasSize
(AssertionInfo info, double[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
FloatArrays.assertHasSize
(AssertionInfo info, float[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
IntArrays.assertHasSize
(AssertionInfo info, int[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
Iterables.assertHasSize
(AssertionInfo info, Iterable<?> actual, int expectedSize) Asserts that the number of elements in the givenIterable
is equal to the expected one.void
LongArrays.assertHasSize
(AssertionInfo info, long[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
Maps.assertHasSize
(AssertionInfo info, Map<?, ?> actual, int expectedSize) Asserts that the number of entries in the givenMap
is equal to the expected one.void
ObjectArrays.assertHasSize
(AssertionInfo info, Object[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
ShortArrays.assertHasSize
(AssertionInfo info, short[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
Strings.assertHasSize
(AssertionInfo info, CharSequence actual, int expectedSize) Asserts that the size of the givenCharSequence
is equal to the expected one.void
Throwables.assertHasStackTraceContaining
(AssertionInfo info, Throwable actual, String description) Asserts that the stack trace of the actualThrowable
contains with the given description.void
Throwables.assertHasSuppressedException
(AssertionInfo info, Throwable actual, Throwable expectedSuppressedException) void
Dates.assertHasTime
(AssertionInfo info, Date actual, long timestamp) Verifies that the actualDate
time is equal to the given timestamp.void
Objects.assertHasToString
(AssertionInfo info, Object actual, String expectedToString) void
Uris.assertHasUserInfo
(AssertionInfo info, URI actual, String expected) void
Urls.assertHasUserInfo
(AssertionInfo info, URL actual, String expected) <V> void
Maps.assertHasValueSatisfying
(AssertionInfo info, Map<?, V> actual, Condition<? super V> valueCondition) Verifies that the givenMap
contains an entry with value satisfyingvalueCondition
.void
Dates.assertHasYear
(AssertionInfo info, Date actual, int year) Verifies that the actualDate
year is equal to the given year.<E> void
Arrays.assertHave
(AssertionInfo info, Failures failures, Conditions conditions, Object array, Condition<E> condition) <E> void
Iterables.assertHave
(AssertionInfo info, Iterable<? extends E> actual, Condition<? super E> condition) Assert that each element of givenIterable
satisfies the given condition.<E> void
ObjectArrays.assertHave
(AssertionInfo info, E[] actual, Condition<? super E> condition) Assert that each element of given array satisfies the given condition.<E> void
Arrays.assertHaveAtLeast
(AssertionInfo info, Failures failures, Conditions conditions, Object array, int times, Condition<E> condition) <E> void
Iterables.assertHaveAtLeast
(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition) An alias method ofIterables.assertAreAtLeast(AssertionInfo, Iterable, int, Condition)
to provide a richer fluent api (same logic, only error message differs).<E> void
ObjectArrays.assertHaveAtLeast
(AssertionInfo info, E[] actual, int times, Condition<? super E> condition) An alias method ofObjectArrays.assertAreAtLeast(AssertionInfo, Object[], int, Condition)
to provide a richer fluent api (same logic, only error message differs).<E> void
Arrays.assertHaveAtMost
(AssertionInfo info, Failures failures, Conditions conditions, Object array, int times, Condition<E> condition) <E> void
Iterables.assertHaveAtMost
(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition) An alias method ofIterables.assertAreAtMost(AssertionInfo, Iterable, int, Condition)
to provide a richer fluent api (same logic, only error message differs).<E> void
ObjectArrays.assertHaveAtMost
(AssertionInfo info, E[] actual, int times, Condition<? super E> condition) An alias method ofObjectArrays.assertAreAtMost(AssertionInfo, Object[], int, Condition)
to provide a richer fluent api (same logic, only error message differs).<E> void
Arrays.assertHaveExactly
(AssertionInfo info, Failures failures, Conditions conditions, Object array, int times, Condition<E> condition) <E> void
Iterables.assertHaveExactly
(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition) An alias method ofIterables.assertAreExactly(AssertionInfo, Iterable, int, Condition)
to provide a richer fluent api (same logic, only error message differs).<E> void
ObjectArrays.assertHaveExactly
(AssertionInfo info, E[] actual, int times, Condition<? super E> condition) An alias method ofObjectArrays.assertAreExactly(AssertionInfo, Object[], int, Condition)
to provide a richer fluent api (same logic, only error message differs).<E> void
Arrays.assertHaveNot
(AssertionInfo info, Failures failures, Conditions conditions, Object array, Condition<E> condition) <T> void
Conditions.assertIs
(AssertionInfo info, T actual, Condition<? super T> condition) Asserts that the actual value satisfies the given
.Condition
<T> void
Lists.assertIs
(AssertionInfo info, List<? extends T> actual, Condition<? super T> condition, Index index) Verifies that the givenList
satisfies the given
at the given index.Condition
void
Files.assertIsAbsolute
(AssertionInfo info, File actual) Asserts that the given file is an absolute path.void
Paths.assertIsAbsolute
(AssertionInfo info, Path actual) void
Dates.assertIsAfter
(AssertionInfo info, Date actual, Date other) Verifies that the actualDate
is strictly after the given one.void
Dates.assertIsAfterOrEqualsTo
(AssertionInfo info, Date actual, Date other) Verifies that the actualDate
is after or equal to the given one.void
Dates.assertIsAfterYear
(AssertionInfo info, Date actual, int year) Verifies that the actualDate
is strictly after the given year.void
Classes.assertIsAnnotation
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is an annotation.static void
Arrays.assertIsArray
(AssertionInfo info, Object array) void
Classes.assertIsAssignableFrom
(AssertionInfo info, Class<?> actual, Class<?>... others) Verifies that the actualClass
is assignable from all theothers
classes.void
Dates.assertIsBefore
(AssertionInfo info, Date actual, Date other) Verifies that the actualDate
is strictly before the given one.void
Dates.assertIsBeforeOrEqualsTo
(AssertionInfo info, Date actual, Date other) Verifies that the actualDate
is before or equal to the given one.void
Dates.assertIsBeforeYear
(AssertionInfo info, Date actual, int year) Verifies that the actualDate
is strictly before the given year.<T extends Comparable<? super T>>
voidComparables.assertIsBetween
(AssertionInfo info, T actual, T start, T end, boolean inclusiveStart, boolean inclusiveEnd) Asserts that the actual value is between start and end, inclusive or not.void
Dates.assertIsBetween
(AssertionInfo info, Date actual, Date start, Date end, boolean inclusiveStart, boolean inclusiveEnd) Verifies that the actualDate
is in start:end period.
start date belongs to the period if inclusiveStart is true.
end date belongs to the period if inclusiveEnd is true.void
Numbers.assertIsBetween
(AssertionInfo info, NUMBER actual, NUMBER start, NUMBER end) Asserts that the actual value is in [start, end] range (start included, end included).void
Futures.assertIsCancelled
(AssertionInfo info, Future<?> actual) Verifies that theFuture
is cancelled.void
Paths.assertIsCanonical
(AssertionInfo info, Path actual) void
Dates.assertIsCloseTo
(AssertionInfo info, Date actual, Date other, long deltaInMilliseconds) Verifies that the actualDate
is close to the other date by less than delta, if difference is equals to delta it is ok.
Note that delta expressed in milliseconds.
Use handy TimeUnit to convert a duration in milliseconds, for example you can express a delta of 5 seconds withTimeUnit.SECONDS.toMillis(5)
.void
Numbers.assertIsCloseTo
(AssertionInfo info, NUMBER actual, NUMBER expected, Offset<NUMBER> offset) Asserts that the actual value is close to the offset.void
Numbers.assertIsCloseToPercentage
(AssertionInfo info, NUMBER actual, NUMBER other, Percentage percentage) Asserts that the actual value is close to the an offset expressed as an percentage value.void
Files.assertIsDirectory
(AssertionInfo info, File actual) Asserts that the given file is an existing directory.void
Paths.assertIsDirectory
(AssertionInfo info, Path actual) void
Futures.assertIsDone
(AssertionInfo info, Future<?> actual) Verifies that theFuture
is done.<A> void
Objects.assertIsEqualToComparingFieldByFieldRecursively
(AssertionInfo info, Object actual, Object other, Map<String, Comparator<?>> comparatorByPropertyOrField, TypeComparators comparatorByType) Assert that the given object is "deeply" equals to other by comparing all fields recursively.<A> void
Objects.assertIsEqualToComparingOnlyGivenFields
(AssertionInfo info, A actual, A other, Map<String, Comparator<?>> comparatorByPropertyOrField, TypeComparators comparatorByType, String... fields) Assert that the given object is lenient equals to other object by comparing given fields value only.<A> void
Objects.assertIsEqualToIgnoringGivenFields
(AssertionInfo info, A actual, A other, Map<String, Comparator<?>> comparatorByPropertyOrField, TypeComparators comparatorByType, String... fields) Assert that the given object is lenient equals to the other by comparing all fields (including inherited fields) unless given ignored ones.<A> void
Objects.assertIsEqualToIgnoringNullFields
(AssertionInfo info, A actual, A other, Map<String, Comparator<?>> comparatorByPropertyOrField, TypeComparators comparatorByType) Assert that the given object is lenient equals by ignoring null fields value on other object (including inherited fields).void
Strings.assertIsEqualToNormalizingNewlines
(AssertionInfo info, CharSequence actual, CharSequence expected) Verifies that twoCharSequence
s are not equal, normalizing newlines.void
Dates.assertIsEqualWithPrecision
(AssertionInfo info, Date actual, Date other, TimeUnit precision) Verifies that the actualDate
is equal to the given one with precision.void
Objects.assertIsExactlyInstanceOf
(AssertionInfo info, Object actual, Class<?> type) Verifies that the actual value is exactly an instance of given type.void
Paths.assertIsExecutable
(AssertionInfo info, Path actual) void
Files.assertIsFile
(AssertionInfo info, File actual) Asserts that the given file is an existing file.void
Classes.assertIsFinal
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is final.void
Objects.assertIsIn
(AssertionInfo info, Object actual, Iterable<?> values) Asserts that the given object is present in the given collection.void
Objects.assertIsIn
(AssertionInfo info, Object actual, Object[] values) Asserts that the given object is present in the given array.void
Dates.assertIsInSameDayAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are chronologically in the same day of month (and thus in the same month and year).void
Dates.assertIsInSameHourAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are in the same hour (and thus in the same day of month, month and year).void
Dates.assertIsInSameHourWindowAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are chronologically in the same hour, day of month, month and year.void
Dates.assertIsInSameMinuteAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are in the same minute, hour, day of month, month and year.void
Dates.assertIsInSameMinuteWindowAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are chronologically in the same minute.void
Dates.assertIsInSameMonthAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are chronologically in the same month (and thus in the same year).void
Dates.assertIsInSameSecondAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are in the same second, minute, hour, day of month, month and year.void
Dates.assertIsInSameSecondWindowAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are chronologically in the same second.void
Dates.assertIsInSameYearAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are in the same year.void
Objects.assertIsInstanceOf
(AssertionInfo info, Object actual, Class<?> type) Verifies that the given object is an instance of the given type.void
Objects.assertIsInstanceOfAny
(AssertionInfo info, Object actual, Class<?>[] types) Verifies that the given object is an instance of any of the given types.void
Classes.assertIsInterface
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is an interface.void
Dates.assertIsInTheFuture
(AssertionInfo info, Date actual) Verifies that the actualDate
is strictly in the future.void
Dates.assertIsInThePast
(AssertionInfo info, Date actual) Verifies that the actualDate
is strictly in the past.void
RealNumbers.assertIsNaN
(AssertionInfo info, NUMBER actual) Verifies that the actual value is equal toNaN
.
It does not rely on the custom comparisonStrategy (if one is set).void
Numbers.assertIsNegative
(AssertionInfo info, NUMBER actual) Asserts that the actual value is negative.void
Paths.assertIsNormalized
(AssertionInfo info, Path actual) <T> void
Conditions.assertIsNot
(AssertionInfo info, T actual, Condition<? super T> condition) Asserts that the actual value does not satisfy the given
.Condition
void
Classes.assertIsNotAnnotation
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is not an annotation.void
Dates.assertIsNotBetween
(AssertionInfo info, Date actual, Date start, Date end, boolean inclusiveStart, boolean inclusiveEnd) Verifies that the actualDate
is not in start:end period..
start date belongs to the period if inclusiveStart is true.
end date belongs to the period if inclusiveEnd is true.void
Futures.assertIsNotCancelled
(AssertionInfo info, Future<?> actual) Verifies that theFuture
is not cancelled.void
Numbers.assertIsNotCloseTo
(AssertionInfo info, NUMBER actual, NUMBER expected, Offset<NUMBER> offset) Asserts that the actual value is not close to the offset.void
Numbers.assertIsNotCloseToPercentage
(AssertionInfo info, NUMBER actual, NUMBER other, Percentage percentage) Asserts that the actual value is not close to the an offset expressed as an percentage value.void
Futures.assertIsNotDone
(AssertionInfo info, Future<?> actual) Verifies that theFuture
is not done.void
Objects.assertIsNotExactlyInstanceOf
(AssertionInfo info, Object actual, Class<?> type) Verifies that the actual value is not exactly an instance of given type.void
Classes.assertIsNotFinal
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is not final.void
Objects.assertIsNotIn
(AssertionInfo info, Object actual, Iterable<?> values) Asserts that the given object is not present in the given collection.void
Objects.assertIsNotIn
(AssertionInfo info, Object actual, Object[] values) Asserts that the given object is not present in the given array.void
Objects.assertIsNotInstanceOf
(AssertionInfo info, Object actual, Class<?> type) Verifies that the given object is not an instance of the given type.void
Objects.assertIsNotInstanceOfAny
(AssertionInfo info, Object actual, Class<?>[] types) Verifies that the given object is not an instance of any of the given types.void
Classes.assertIsNotInterface
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is not an interface.void
RealNumbers.assertIsNotNaN
(AssertionInfo info, NUMBER actual) Verifies that the actual value is not equal toNaN
.void
Numbers.assertIsNotNegative
(AssertionInfo info, NUMBER actual) Asserts that the actual value is not negative.void
Objects.assertIsNotOfAnyClassIn
(AssertionInfo info, Object actual, Class<?>[] types) Verifies that the actual value type is not in given types.void
Numbers.assertIsNotPositive
(AssertionInfo info, NUMBER actual) Asserts that the actual value is not positive.void
Numbers.assertIsNotZero
(AssertionInfo info, NUMBER actual) Asserts that the actual value is not equal to zero.
It does not rely on the custom comparisonStrategy (if one is set).void
Objects.assertIsOfAnyClassIn
(AssertionInfo info, Object actual, Class<?>[] types) Verifies that the actual value type is in given types.void
Numbers.assertIsOne
(AssertionInfo info, NUMBER actual) Asserts that the actual value is equal to one.
It does not rely on the custom comparisonStrategy (if one is set).void
Numbers.assertIsPositive
(AssertionInfo info, NUMBER actual) Asserts that the actual value is positive.void
Classes.assertIsProtected
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is protected.void
Classes.assertIsPublic
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is public.void
Paths.assertIsReadable
(AssertionInfo info, Path actual) void
Paths.assertIsRegularFile
(AssertionInfo info, Path actual) void
Files.assertIsRelative
(AssertionInfo info, File actual) Asserts that the given file is a relative path.void
Paths.assertIsRelative
(AssertionInfo info, Path actual) (package private) void
Arrays.assertIsSorted
(AssertionInfo info, Failures failures, Object array) void
BooleanArrays.assertIsSorted
(AssertionInfo info, boolean[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.void
ByteArrays.assertIsSorted
(AssertionInfo info, byte[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.void
CharArrays.assertIsSorted
(AssertionInfo info, char[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.void
DoubleArrays.assertIsSorted
(AssertionInfo info, double[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.void
FloatArrays.assertIsSorted
(AssertionInfo info, float[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.void
IntArrays.assertIsSorted
(AssertionInfo info, int[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.void
Lists.assertIsSorted
(AssertionInfo info, List<?> actual) Verifies that the actual list is sorted in ascending order according to the natural ordering of its elements.void
LongArrays.assertIsSorted
(AssertionInfo info, long[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.void
ObjectArrays.assertIsSorted
(AssertionInfo info, Object[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.void
ShortArrays.assertIsSorted
(AssertionInfo info, short[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.(package private) static <T> void
Arrays.assertIsSortedAccordingToComparator
(AssertionInfo info, Failures failures, Object array, Comparator<T> comparator) void
BooleanArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, boolean[] actual, Comparator<? super Boolean> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.void
ByteArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, byte[] actual, Comparator<? super Byte> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.void
CharArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, char[] actual, Comparator<? super Character> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.void
DoubleArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, double[] actual, Comparator<? super Double> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.void
FloatArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, float[] actual, Comparator<? super Float> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.void
IntArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, int[] actual, Comparator<? super Integer> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.void
Lists.assertIsSortedAccordingToComparator
(AssertionInfo info, List<?> actual, Comparator<?> comparator) Verifies that the actual list is sorted according to the given comparator. Empty lists are considered sorted whatever the comparator is. One element lists are considered sorted if the element is compatible with comparator.void
LongArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, long[] actual, Comparator<? super Long> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.<E> void
ObjectArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, E[] actual, Comparator<? super E> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.void
ShortArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, short[] actual, Comparator<? super Short> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.void
Numbers.assertIsStrictlyBetween
(AssertionInfo info, NUMBER actual, NUMBER start, NUMBER end) Asserts that the actual value is in ]start, end[ range (start excluded, end excluded).void
Arrays.assertIsSubsetOf
(AssertionInfo info, Failures failures, Object actual, Iterable<?> values) void
Iterables.assertIsSubsetOf
(AssertionInfo info, Iterable<?> actual, Iterable<?> values) Verifies that the actualIterable
is a subset of valuesIterable
.void
ObjectArrays.assertIsSubsetOf
(AssertionInfo info, Object actual, Iterable<?> values) void
Strings.assertIsSubstringOf
(AssertionInfo info, CharSequence actual, CharSequence sequence) void
Paths.assertIsSymbolicLink
(AssertionInfo info, Path actual) void
Dates.assertIsToday
(AssertionInfo info, Date actual) Verifies that the actualDate
is today, by comparing only year, month and day of actual to today (ie.void
Paths.assertIsWritable
(AssertionInfo info, Path actual) void
Numbers.assertIsZero
(AssertionInfo info, NUMBER actual) Asserts that the actual value is equal to zero.
It does not rely on the custom comparisonStrategy (if one is set).private void
Iterables.assertIterableContainsGivenValues
(Iterable<?> actual, Object[] values, AssertionInfo info) void
Strings.assertJavaBlank
(AssertionInfo info, CharSequence actual) Asserts that the givenCharSequence
isNull
, empty or contains only whitespace according toCharacter.isWhitespace(char)
.<T extends Comparable<? super T>>
voidComparables.assertLessThan
(AssertionInfo info, T actual, T other) Asserts that the actual value is less than the other one.<T extends Comparable<? super T>>
voidComparables.assertLessThanOrEqualTo
(AssertionInfo info, T actual, T other) Asserts that the actual value is less than or equal to the other one.void
Characters.assertLowerCase
(AssertionInfo info, Character actual) Asserts that the actual value is a lowercase character.void
Strings.assertMatches
(AssertionInfo info, CharSequence actual, CharSequence regex) Verifies that the givenCharSequence
matches the given regular expression.void
Strings.assertMatches
(AssertionInfo info, CharSequence actual, Pattern pattern) Verifies that the givenCharSequence
matches the given regular expression.<E> void
Iterables.assertNoneMatch
(AssertionInfo info, Iterable<? extends E> actual, Predicate<? super E> predicate, PredicateDescription predicateDescription) void
Strings.assertNotBlank
(AssertionInfo info, CharSequence actual) Asserts that the givenCharSequence
is notNull
, not empty and contains not only whitespace.(package private) void
Arrays.assertNotEmpty
(AssertionInfo info, Failures failures, Object array) void
BooleanArrays.assertNotEmpty
(AssertionInfo info, boolean[] actual) Asserts that the given array is not empty.void
ByteArrays.assertNotEmpty
(AssertionInfo info, byte[] actual) Asserts that the given array is not empty.void
CharArrays.assertNotEmpty
(AssertionInfo info, char[] actual) Asserts that the given array is not empty.void
DoubleArrays.assertNotEmpty
(AssertionInfo info, double[] actual) Asserts that the given array is not empty.void
FloatArrays.assertNotEmpty
(AssertionInfo info, float[] actual) Asserts that the given array is not empty.void
IntArrays.assertNotEmpty
(AssertionInfo info, int[] actual) Asserts that the given array is not empty.void
Iterables.assertNotEmpty
(AssertionInfo info, Iterable<?> actual) Asserts that the givenIterable
is not empty.void
LongArrays.assertNotEmpty
(AssertionInfo info, long[] actual) Asserts that the given array is not empty.void
Maps.assertNotEmpty
(AssertionInfo info, Map<?, ?> actual) Asserts that the givenMap
is not empty.void
ObjectArrays.assertNotEmpty
(AssertionInfo info, Object[] actual) Asserts that the given array is not empty.void
ShortArrays.assertNotEmpty
(AssertionInfo info, short[] actual) Asserts that the given array is not empty.void
Strings.assertNotEmpty
(AssertionInfo info, CharSequence actual) Asserts that the givenCharSequence
is not empty.void
Booleans.assertNotEqual
(AssertionInfo info, Boolean actual, boolean other) Asserts that two longs are not equal.<T> void
Comparables.assertNotEqual
(AssertionInfo info, T actual, T other) Asserts that two T instances are not equal.void
Objects.assertNotEqual
(AssertionInfo info, Object actual, Object other) Asserts that two objects are not equal.<T extends Comparable<? super T>>
voidComparables.assertNotEqualByComparison
(AssertionInfo info, T actual, T other) Asserts that two
s are not equal by invokingComparable
.Comparable.compareTo(Object)
Note that it does not rely on the customComparables.comparisonStrategy
if one has been set.void
Strings.assertNotEqualsIgnoringCase
(AssertionInfo info, CharSequence actual, CharSequence expected) Verifies that twoCharSequence
s are not equal, ignoring case considerations.void
Strings.assertNotEqualsIgnoringWhitespace
(AssertionInfo info, CharSequence actual, CharSequence expected) Verifies that twoCharSequence
s are not equal, ignoring any differences in whitespace.void
Strings.assertNotEqualsNormalizingWhitespace
(AssertionInfo info, CharSequence actual, CharSequence expected) Verifies that twoCharSequence
s are not equal, after the whitespace of both strings has been normalized.void
Strings.assertNotJavaBlank
(AssertionInfo info, CharSequence actual) Asserts that the givenCharSequence
is notNull
, not empty or contains not only whitespace according toCharacter.isWhitespace(char)
.private static void
Arrays.assertNotNull
(AssertionInfo info, Object array) private static void
Booleans.assertNotNull
(AssertionInfo info, Boolean actual) private static void
Classes.assertNotNull
(AssertionInfo info, Class<?> actual) protected static <T> void
Comparables.assertNotNull
(AssertionInfo info, T actual) private void
Dates.assertNotNull
(AssertionInfo info, Date actual) private static void
Files.assertNotNull
(AssertionInfo info, File actual) private void
Futures.assertNotNull
(AssertionInfo info, Future<?> actual) private static void
InputStreams.assertNotNull
(AssertionInfo info, InputStream stream) (package private) void
Iterables.assertNotNull
(AssertionInfo info, Iterable<?> actual) private void
Lists.assertNotNull
(AssertionInfo info, List<?> actual) private void
Maps.assertNotNull
(AssertionInfo info, Map<?, ?> actual) void
Objects.assertNotNull
(AssertionInfo info, Object actual) Asserts that the given object is notnull
.private static void
Paths.assertNotNull
(AssertionInfo info, Path actual) private void
Strings.assertNotNull
(AssertionInfo info, CharSequence actual) private static void
Throwables.assertNotNull
(AssertionInfo info, Throwable actual) void
Objects.assertNotSame
(AssertionInfo info, Object actual, Object other) Asserts that two objects do not refer to the same object.void
Objects.assertNull
(AssertionInfo info, Object actual) Asserts that the given object isnull
.(package private) void
Arrays.assertNullOrEmpty
(AssertionInfo info, Failures failures, Object array) void
BooleanArrays.assertNullOrEmpty
(AssertionInfo info, boolean[] actual) Asserts that the given array isnull
or empty.void
ByteArrays.assertNullOrEmpty
(AssertionInfo info, byte[] actual) Asserts that the given array isnull
or empty.void
CharArrays.assertNullOrEmpty
(AssertionInfo info, char[] actual) Asserts that the given array isnull
or empty.void
DoubleArrays.assertNullOrEmpty
(AssertionInfo info, double[] actual) Asserts that the given array isnull
or empty.void
FloatArrays.assertNullOrEmpty
(AssertionInfo info, float[] actual) Asserts that the given array isnull
or empty.void
IntArrays.assertNullOrEmpty
(AssertionInfo info, int[] actual) Asserts that the given array isnull
or empty.void
Iterables.assertNullOrEmpty
(AssertionInfo info, Iterable<?> actual) Asserts that the given
isIterable
null
or empty.void
LongArrays.assertNullOrEmpty
(AssertionInfo info, long[] actual) Asserts that the given array isnull
or empty.void
Maps.assertNullOrEmpty
(AssertionInfo info, Map<?, ?> actual) Asserts that the givenMap
isnull
or empty.void
ObjectArrays.assertNullOrEmpty
(AssertionInfo info, Object[] actual) Asserts that the given array isnull
or empty.void
ShortArrays.assertNullOrEmpty
(AssertionInfo info, short[] actual) Asserts that the given array isnull
or empty.void
Strings.assertNullOrEmpty
(AssertionInfo info, CharSequence actual) Asserts that the givenCharSequence
isnull
or empty.void
Objects.assertSame
(AssertionInfo info, Object actual, Object expected) Asserts that two objects refer to the same object.void
Files.assertSameContentAs
(AssertionInfo info, File actual, Charset actualCharset, File expected, Charset expectedCharset) Asserts that the given files have same content.void
InputStreams.assertSameContentAs
(AssertionInfo info, InputStream actual, InputStream expected) Asserts that the given InputStreams have same content.(package private) void
Arrays.assertStartsWith
(AssertionInfo info, Failures failures, Object actual, Object sequence) void
BooleanArrays.assertStartsWith
(AssertionInfo info, boolean[] actual, boolean[] sequence) Verifies that the given array starts with the given sequence of values, without any other values between them.void
ByteArrays.assertStartsWith
(AssertionInfo info, byte[] actual, byte[] sequence) Verifies that the given array starts with the given sequence of values, without any other values between them.void
ByteArrays.assertStartsWith
(AssertionInfo info, byte[] actual, int[] sequence) Verifies that the given array starts with the given sequence of values, without any other values between them.void
CharArrays.assertStartsWith
(AssertionInfo info, char[] actual, char[] sequence) Verifies that the given array starts with the given sequence of values, without any other values between them.void
DoubleArrays.assertStartsWith
(AssertionInfo info, double[] actual, double[] sequence) Verifies that the given array starts with the given sequence of values, without any other values between them.void
FloatArrays.assertStartsWith
(AssertionInfo info, float[] actual, float[] sequence) Verifies that the given array starts with the given sequence of values, without any other values between them.void
IntArrays.assertStartsWith
(AssertionInfo info, int[] actual, int[] sequence) Verifies that the given array starts with the given sequence of values, without any other values between them.void
Iterables.assertStartsWith
(AssertionInfo info, Iterable<?> actual, Object[] sequence) Verifies that the givenIterable
starts with the given sequence of objects, without any other objects between them.void
LongArrays.assertStartsWith
(AssertionInfo info, long[] actual, long[] sequence) Verifies that the given array starts with the given sequence of values, without any other values between them.void
ObjectArrays.assertStartsWith
(AssertionInfo info, Object[] actual, Object[] sequence) Verifies that the given array starts with the given sequence of objects, without any other objects between them.void
Paths.assertStartsWith
(AssertionInfo info, Path actual, Path start) void
ShortArrays.assertStartsWith
(AssertionInfo info, short[] actual, short[] sequence) Verifies that the given array starts with the given sequence of values, without any other values between them.void
Strings.assertStartsWith
(AssertionInfo info, CharSequence actual, CharSequence prefix) Verifies that the givenCharSequence
starts with the given prefix.void
Paths.assertStartsWithRaw
(AssertionInfo info, Path actual, Path other) private static void
Arrays.assertThatArrayComponentTypeIsSortable
(AssertionInfo info, Failures failures, Object array) void
Characters.assertUpperCase
(AssertionInfo info, Character actual) Asserts that the actual value is a uppercase character.void
Strings.assertXmlEqualsTo
(AssertionInfo info, CharSequence actualXml, CharSequence expectedXml) static void
CommonValidations.checkIterableIsNotNull
(AssertionInfo info, Iterable<?> set) static void
CommonValidations.checkLineCounts
(Object actual, int lineCountOfActual, int lineCountOfOther, AssertionInfo info) (package private) static void
CommonValidations.checkSameSizes
(AssertionInfo info, Object actual, int sizeOfActual, int sizeOfOther) static void
CommonValidations.checkSizes
(Object actual, int sizeOfActual, int sizeOfOther, AssertionInfo info) private static boolean
Arrays.commonChecks
(AssertionInfo info, Object actual, Object sequence) private boolean
Iterables.commonCheckThatIterableAssertionSucceeds
(AssertionInfo info, Iterable<?> actual, Object[] sequence) private <T> boolean
Lists.conditionIsMetAtIndex
(AssertionInfo info, List<T> actual, Condition<? super T> condition, Index index) private void
Classes.doAssertHasMethods
(AssertionInfo info, Class<?> actual, Set<Method> actualMethods, boolean declared, String... expectedMethods) private <K,
V> void Maps.doCommonContainsCheck
(AssertionInfo info, Map<K, V> actual, Map.Entry<? extends K, ? extends V>[] entries) Failures.failure
(AssertionInfo info, AssertionErrorFactory factory) Creates a
following this pattern: creates aAssertionError
usingAssertionError
as the error message if such value is notoverridingErrorMessage()
null
, or uses the given
to create anAssertionErrorFactory
, prepending the value ofAssertionError
to the error messagedescription()
Failures.failure
(AssertionInfo info, ErrorMessageFactory message) Creates a
following this pattern: creates aAssertionError
usingAssertionError
as the error message if such value is notoverridingErrorMessage()
null
, or uses the given
to create the detail message of theErrorMessageFactory
, prepending the value ofAssertionError
to the error messagedescription()
Failures.failureIfErrorMessageIsOverridden
(AssertionInfo info) private <E> List<E>
Arrays.filterElements
(AssertionInfo info, Failures failures, Conditions conditions, Object array, Condition<E> condition, boolean negateCondition) private <E> List<E>
Arrays.getElementsMatchingCondition
(AssertionInfo info, Failures failures, Conditions conditions, Object array, Condition<E> condition) private <E> List<E>
Arrays.getElementsNotMatchingCondition
(AssertionInfo info, Failures failures, Conditions conditions, Object array, Condition<E> condition) static void
CommonValidations.hasSameSizeAsCheck
(AssertionInfo info, Object actual, Iterable<?> other, int sizeOfActual) static void
CommonValidations.hasSameSizeAsCheck
(AssertionInfo info, Object actual, Object other, int sizeOfActual) static void
CommonValidations.hasSameSizeAsCheck
(AssertionInfo info, Object actual, Map<?, ?> other, int sizeOfActual) void
Dates.hasSameTimeAs
(AssertionInfo info, Date actual, Date date) Verifies that the actualDate
is equal to the given date by comparing their time.private boolean
Objects.haveSameClass
(Object actual, Object other, AssertionInfo info) private boolean
Files.isAbsolutePath
(AssertionInfo info, File actual) private boolean
Objects.isInstanceOfClass
(Object actual, Class<?> clazz, AssertionInfo info) private boolean
Objects.isOfOneOfGivenTypes
(Object actual, Class<?>[] types, AssertionInfo info) private boolean
Objects.objectIsInstanceOfOneOfGivenClasses
(Object actual, Class<?>[] types, AssertionInfo info)