Uses of Interface
org.assertj.core.api.AssertionInfo

Packages that use AssertionInfo

Package	Description
org.assertj.core.api
org.assertj.core.error
org.assertj.core.internal

Uses of AssertionInfo in org.assertj.core.api

Classes in org.assertj.core.api that implement AssertionInfo

Modifier and Type	Class	Description
class	WritableAssertionInfo	Writable information about an assertion.

Uses of AssertionInfo in org.assertj.core.error

Methods in org.assertj.core.error with parameters of type AssertionInfo

Modifier and Type	Method	Description
String	UnsatisfiedRequirement.describe(int index, AssertionInfo info)
String	UnsatisfiedRequirement.describe(AssertionInfo info)
static String	ZippedElementsShouldSatisfy.ZipSatisfyError.describe(AssertionInfo info, ZippedElementsShouldSatisfy.ZipSatisfyError satisfyError)
static ErrorMessageFactory	ElementsShouldSatisfy.elementsShouldSatisfy(Object actual, List<UnsatisfiedRequirement> elementsNotSatisfyingRestrictions, AssertionInfo info)
static ErrorMessageFactory	ElementsShouldSatisfy.elementsShouldSatisfyAny(Object actual, List<UnsatisfiedRequirement> elementsNotSatisfyingRequirements, AssertionInfo info)
static ErrorMessageFactory	ElementsShouldSatisfy.elementsShouldSatisfyExactly(Object actual, Map<Integer,UnsatisfiedRequirement> unsatisfiedRequirements, AssertionInfo info)
static ErrorMessageFactory	ZippedElementsShouldSatisfy.zippedElementsShouldSatisfy(AssertionInfo info, Iterable<?> actual, Iterable<?> other, List<ZippedElementsShouldSatisfy.ZipSatisfyError> zipSatisfyErrors)

Uses of AssertionInfo in org.assertj.core.internal

Methods in org.assertj.core.internal with parameters of type AssertionInfo

Modifier and Type	Method	Description
<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)
<K, V> void	Maps.assertAllSatisfy(AssertionInfo info, Map<K,V> actual, BiConsumer<? super K,? super V> entryRequirements)
<E> void	Iterables.assertAnyMatch(AssertionInfo info, Iterable<? extends E> actual, Predicate<? super E> predicate, PredicateDescription predicateDescription)
<E> void	Iterables.assertAnySatisfy(AssertionInfo info, Iterable<? extends E> actual, Consumer<? super E> requirements)
<K, V> void	Maps.assertAnySatisfy(AssertionInfo info, Map<K,V> actual, BiConsumer<? super K,? super V> entryRequirements)
<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 given Iterable 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 actual Iterable 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 actual Iterable 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 actual Iterable 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 given Iterable 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	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.
Exception	Futures.assertCompletedExceptionallyWithin(AssertionInfo info, Future<?> actual, long timeout, TimeUnit unit)
Exception	Futures.assertCompletedExceptionallyWithin(AssertionInfo info, Future<?> actual, Duration timeout)
void	Arrays.assertContains(AssertionInfo info, Failures failures, Object actual, Object values)
void	Arrays2D.assertContains(AssertionInfo info, Failures failures, Object array, Object value, Index index)
void	Boolean2DArrays.assertContains(AssertionInfo info, boolean[][] actual, boolean[] value, Index index)	Verifies that the given array contains the given value at the given 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	Byte2DArrays.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, 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	Char2DArrays.assertContains(AssertionInfo info, char[][] actual, char[] 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	Double2DArrays.assertContains(AssertionInfo info, double[][] actual, double[] 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	Float2DArrays.assertContains(AssertionInfo info, float[][] actual, float[] 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	Int2DArrays.assertContains(AssertionInfo info, int[][] actual, int[] 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 given Iterable contains the given values, in any order.
void	Lists.assertContains(AssertionInfo info, List<?> actual, Object value, Index index)	Verifies that the given List contains the given object at the given index.
void	Long2DArrays.assertContains(AssertionInfo info, long[][] actual, long[] value, Index index)	Verifies that the given array contains the given value 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)
void	Object2DArrays.assertContains(AssertionInfo info, ELEMENT[][] actual, ELEMENT[] value, Index index)	Verifies that the given array contains the given object at the given index.
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	Short2DArrays.assertContains(AssertionInfo info, short[][] actual, short[] value, Index index)	Verifies that the given array contains the given value 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)
void	Iterables.assertContainsAll(AssertionInfo info, Iterable<?> actual, Iterable<?> other)	Asserts that the given Iterable contains all the elements of the other Iterable, 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 given Iterable, in any order.
<K, V> void	Maps.assertContainsAllEntriesOf(AssertionInfo info, Map<K,V> actual, Map<? extends K,? extends V> other)
void	Classes.assertContainsAnnotations(AssertionInfo info, Class<?> actual, Class<? extends Annotation>[] annotations)	Verifies that the actual Class contains the given Annotations.
void	Arrays.assertContainsAnyOf(AssertionInfo info, Failures failures, Object actual, Object values)
void	BooleanArrays.assertContainsAnyOf(AssertionInfo info, boolean[] actual, boolean[] values)
void	ByteArrays.assertContainsAnyOf(AssertionInfo info, byte[] actual, byte[] values)
void	CharArrays.assertContainsAnyOf(AssertionInfo info, char[] actual, char[] values)
void	DoubleArrays.assertContainsAnyOf(AssertionInfo info, double[] actual, double[] values)
void	FloatArrays.assertContainsAnyOf(AssertionInfo info, float[] actual, float[] values)
void	IntArrays.assertContainsAnyOf(AssertionInfo info, int[] actual, int[] values)
void	Iterables.assertContainsAnyOf(AssertionInfo info, Iterable<?> actual, Object[] values)	Asserts that the given Iterable contains at least one of the given values.
void	LongArrays.assertContainsAnyOf(AssertionInfo info, long[] actual, long[] values)
<K, V> void	Maps.assertContainsAnyOf(AssertionInfo info, Map<K,V> actual, Map.Entry<? extends K,? extends V>[] entries)
void	ObjectArrays.assertContainsAnyOf(AssertionInfo info, Object[] actual, Object[] values)
void	ShortArrays.assertContainsAnyOf(AssertionInfo info, short[] actual, short[] values)
void	Strings.assertContainsAnyOf(AssertionInfo info, CharSequence actual, CharSequence[] 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 given Iterable 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)
void	ObjectArrays.assertContainsExactly(AssertionInfo info, Object[] actual, Object[] values)
void	ShortArrays.assertContainsExactly(AssertionInfo info, short[] actual, short[] 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)
void	Strings.assertContainsIgnoringNewLines(AssertionInfo info, CharSequence actual, CharSequence... values)
<K, V> void	Maps.assertContainsKey(AssertionInfo info, Map<K,V> actual, K key)
<K, V> void	Maps.assertContainsKeys(AssertionInfo info, Map<K,V> actual, K[] keys)
void	Iterables.assertContainsNull(AssertionInfo info, Iterable<?> actual)	Asserts that the given Iterable contains at least a null element.
void	ObjectArrays.assertContainsNull(AssertionInfo info, Object[] actual)	Asserts that the given array contains at least a null element.
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[] expectedValues)	Asserts that the given Iterable 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)
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)
<K, V> void	Maps.assertContainsOnlyKeys(AssertionInfo info, Map<K,V> actual, Iterable<? extends K> keys)
<K, V> void	Maps.assertContainsOnlyKeys(AssertionInfo info, Map<K,V> actual, K[] keys)
void	Iterables.assertContainsOnlyNulls(AssertionInfo info, Iterable<?> actual)	Asserts that the given Iterable contains only null elements and nothing else.
void	ObjectArrays.assertContainsOnlyNulls(AssertionInfo info, Object[] actual)	Asserts that the given array contains only null elements.
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 given Iterable 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)
void	Strings.assertContainsPattern(AssertionInfo info, CharSequence actual, CharSequence regex)
void	Strings.assertContainsPattern(AssertionInfo info, CharSequence actual, Matcher matcher)
void	Strings.assertContainsPattern(AssertionInfo info, CharSequence actual, Pattern pattern)
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 Iterable contains the given sequence of objects, without any other objects between them.
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)
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 Iterable contains the given subsequence of objects (possibly with other values between them).
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).
void	Strings.assertContainsSubsequence(AssertionInfo info, CharSequence actual, CharSequence[] subsequence)
<K, V> void	Maps.assertContainsValue(AssertionInfo info, Map<K,V> actual, V value)
<K, V> void	Maps.assertContainsValues(AssertionInfo info, Map<K,V> actual, V[] values)
void	Arrays2D.assertDoesNotContain(AssertionInfo info, Failures failures, Object array, Object value, Index index)
void	Boolean2DArrays.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	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	Byte2DArrays.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, 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	Char2DArrays.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	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	Double2DArrays.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	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	Float2DArrays.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	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	Int2DArrays.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	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 given Iterable does not contain the given values.
void	Lists.assertDoesNotContain(AssertionInfo info, List<?> actual, Object value, Index index)	Verifies that the given List does not contain the given object at the given index.
void	Long2DArrays.assertDoesNotContain(AssertionInfo info, long[][] actual, long[] value, Index index)	Verifies that the given array does not contain the given value 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)
void	Object2DArrays.assertDoesNotContain(AssertionInfo info, ELEMENT[][] actual, ELEMENT[] value, Index index)	Verifies that the given array does not contain the given object at the given index.
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	Short2DArrays.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	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... values)
<T> void	Iterables.assertDoesNotContainAnyElementsOf(AssertionInfo info, Iterable<? extends T> actual, Iterable<? extends T> iterable)	Asserts that the given Iterable does not contain the given values.
<T> void	ObjectArrays.assertDoesNotContainAnyElementsOf(AssertionInfo info, Object[] actual, Iterable<? extends T> iterable)
void	Strings.assertDoesNotContainIgnoringCase(AssertionInfo info, CharSequence actual, CharSequence... values)
<K, V> void	Maps.assertDoesNotContainKey(AssertionInfo info, Map<K,V> actual, K key)
<K, V> void	Maps.assertDoesNotContainKeys(AssertionInfo info, Map<K,V> actual, K[] keys)
void	Iterables.assertDoesNotContainNull(AssertionInfo info, Iterable<?> actual)	Asserts that the given Iterable 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)
void	Strings.assertDoesNotContainPattern(AssertionInfo info, CharSequence actual, Pattern pattern)
void	Iterables.assertDoesNotContainSequence(AssertionInfo info, Iterable<?> actual, Object[] sequence)	Verifies that the given Iterable does not contain the given sequence of objects in order.
void	ObjectArrays.assertDoesNotContainSequence(AssertionInfo info, Object[] actual, Object[] sequence)	Verifies that the given array does not contain the given sequence of objects in order.
void	Iterables.assertDoesNotContainSubsequence(AssertionInfo info, Iterable<?> actual, Object[] subsequence)	Verifies that the given Iterable does not contain the given subsequence of objects (possibly with other values between them).
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)
void	Strings.assertDoesNotEndWith(AssertionInfo info, CharSequence actual, CharSequence suffix)
void	Strings.assertDoesNotEndWithIgnoringCase(AssertionInfo info, CharSequence actual, CharSequence 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.
<E> void	ObjectArrays.assertDoesNotHaveAnyElementsOfTypes(AssertionInfo info, E[] actual, Class<?>... unexpectedTypes)
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 given Iterable 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)
<A> void	Objects.assertDoesNotHaveSameHashCodeAs(AssertionInfo info, A actual, Object other)
void	Objects.assertDoesNotHaveToString(AssertionInfo info, Object actual, String otherToString)
void	Strings.assertDoesNotMatch(AssertionInfo info, CharSequence actual, CharSequence regex)
void	Strings.assertDoesNotMatch(AssertionInfo info, CharSequence actual, Pattern pattern)
void	Strings.assertDoesNotStartWith(AssertionInfo info, CharSequence actual, CharSequence prefix)
void	Strings.assertDoesNotStartWithIgnoringCase(AssertionInfo info, CharSequence actual, CharSequence prefix)
<E> void	Iterables.assertDoNotHave(AssertionInfo info, Iterable<? extends E> actual, Condition<? super E> condition)	Assert that each element of given Iterable 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.
void	Arrays2D.assertEmpty(AssertionInfo info, Failures failures, Object array)
void	Boolean2DArrays.assertEmpty(AssertionInfo info, boolean[][] actual)	Asserts that the given array is empty.
void	BooleanArrays.assertEmpty(AssertionInfo info, boolean[] actual)	Asserts that the given array is empty.
void	Byte2DArrays.assertEmpty(AssertionInfo info, byte[][] actual)	Asserts that the given array is empty.
void	ByteArrays.assertEmpty(AssertionInfo info, byte[] actual)	Asserts that the given array is empty.
void	Char2DArrays.assertEmpty(AssertionInfo info, char[][] actual)	Asserts that the given array is empty.
void	CharArrays.assertEmpty(AssertionInfo info, char[] actual)	Asserts that the given array is empty.
void	Double2DArrays.assertEmpty(AssertionInfo info, double[][] actual)	Asserts that the given array is empty.
void	DoubleArrays.assertEmpty(AssertionInfo info, double[] actual)	Asserts that the given array is empty.
void	Float2DArrays.assertEmpty(AssertionInfo info, float[][] actual)	Asserts that the given array is empty.
void	FloatArrays.assertEmpty(AssertionInfo info, float[] actual)	Asserts that the given array is empty.
void	Int2DArrays.assertEmpty(AssertionInfo info, int[][] 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 given Iterable is empty.
void	Long2DArrays.assertEmpty(AssertionInfo info, long[][] actual)	Asserts that the given array is empty.
void	LongArrays.assertEmpty(AssertionInfo info, long[] actual)	Asserts that the given array is empty.
void	Maps.assertEmpty(AssertionInfo info, Map<?,?> actual)
void	Object2DArrays.assertEmpty(AssertionInfo info, ELEMENT[][] actual)	Asserts that the given array is empty.
void	ObjectArrays.assertEmpty(AssertionInfo info, Object[] actual)	Asserts that the given array is empty.
void	Short2DArrays.assertEmpty(AssertionInfo info, short[][] 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)
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 given Iterable ends with the given sequence of objects, without any other objects between them.
void	Iterables.assertEndsWith(AssertionInfo info, Iterable<?> actual, Object first, Object[] rest)	Verifies that the given Iterable 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	ObjectArrays.assertEndsWith(AssertionInfo info, Object[] actual, Object first, Object[] rest)	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 other)
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)
void	Strings.assertEndsWithIgnoringCase(AssertionInfo info, CharSequence actual, CharSequence suffix)
void	Paths.assertEndsWithRaw(AssertionInfo info, Path actual, Path end)
<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)
<T> void	Comparables.assertEqualByComparison(AssertionInfo info, Comparable<? super T> actual, T expected)	Asserts that two Comparables are equal by invoking Comparable.compareTo(Object). Note that it does not rely on the custom Comparables.comparisonStrategy if one has been set.
void	Strings.assertEqualsIgnoringCase(AssertionInfo info, CharSequence actual, CharSequence expected)
void	Strings.assertEqualsIgnoringWhitespace(AssertionInfo info, CharSequence actual, CharSequence expected)
void	Strings.assertEqualsNormalizingPunctuationAndWhitespace(AssertionInfo info, CharSequence actual, CharSequence expected)
void	Strings.assertEqualsNormalizingWhitespace(AssertionInfo info, CharSequence actual, CharSequence expected)
void	Strings.assertEqualsToNormalizingUnicode(AssertionInfo info, CharSequence actual, CharSequence expected)
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)
Exception	Futures.assertFailedWithin(AssertionInfo info, Future<?> actual, long timeout, TimeUnit unit)
Exception	Futures.assertFailedWithin(AssertionInfo info, Future<?> actual, Duration timeout)
<T> void	Comparables.assertGreaterThan(AssertionInfo info, Comparable<? super T> actual, T other)
<T> void	Comparables.assertGreaterThanOrEqualTo(AssertionInfo info, Comparable<? super T> actual, T other)
<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 given List satisfies the given Condition at the given index.
<A> void	Objects.assertHasAllNullFieldsOrPropertiesExcept(AssertionInfo info, A actual, String... propertiesOrFieldsToIgnore)
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)	Asserts that the actual Throwable has a cause.
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 actual Throwable is exactly an instance of the given type.
void	Throwables.assertHasCauseInstanceOf(AssertionInfo info, Throwable actual, Class<? extends Throwable> type)	Assert that the cause of actual Throwable is an instance of the given type.
void	Throwables.assertHasCauseReference(AssertionInfo info, Throwable actual, Throwable expectedCause)	Asserts that the actual Throwable has a cause that refers to the expected one.
void	Spliterators.assertHasCharacteristics(AssertionInfo info, Spliterator<?> actual, int... characteristics)	Asserts the given Spliterator has the given characteristics.
void	Files.assertHasContent(AssertionInfo info, File actual, String expected, Charset charset)	Asserts that the given file has the given text content.
void	Dates.assertHasDayOfMonth(AssertionInfo info, Date actual, int dayOfMonth)	Verifies that the actual Date day of month is equal to the given day of month.
void	Dates.assertHasDayOfWeek(AssertionInfo info, Date actual, int dayOfWeek)	Verifies that the actual Date day of week is equal to the given day of week.
void	Classes.assertHasDeclaredFields(AssertionInfo info, Class<?> actual, String... fields)	Verifies that the actual Class has the declared fields.
void	Classes.assertHasDeclaredMethods(AssertionInfo info, Class<?> actual, String... methods)	Verifies that the actual Class has the declared methods.
void	Files.assertHasDigest(AssertionInfo info, File actual, String algorithm, byte[] expected)
void	Files.assertHasDigest(AssertionInfo info, File actual, String algorithm, String expected)
void	Files.assertHasDigest(AssertionInfo info, File actual, MessageDigest digest, byte[] expected)
void	Files.assertHasDigest(AssertionInfo info, File actual, MessageDigest digest, String expected)
void	Paths.assertHasDigest(AssertionInfo info, Path actual, String algorithm, byte[] expected)
void	Paths.assertHasDigest(AssertionInfo info, Path actual, String algorithm, String expected)
void	Paths.assertHasDigest(AssertionInfo info, Path actual, MessageDigest digest, byte[] expected)
void	Paths.assertHasDigest(AssertionInfo info, Path actual, MessageDigest digest, String expected)
void	Arrays2D.assertHasDimensions(AssertionInfo info, Failures failures, Object array2d, int expectedNumberOfRows, int expectedRowSize)
void	Boolean2DArrays.assertHasDimensions(AssertionInfo info, boolean[][] actual, int expectedFirstDimension, int expectedSecondDimension)	Asserts that the number of elements in the given array is equal to the expected one.
void	Byte2DArrays.assertHasDimensions(AssertionInfo info, byte[][] actual, int expectedFirstDimension, int expectedSecondDimension)	Asserts that the number of elements in the given array is equal to the expected one.
void	Char2DArrays.assertHasDimensions(AssertionInfo info, char[][] actual, int expectedFirstDimension, int expectedSecondDimension)	Asserts that the number of elements in the given array is equal to the expected one.
void	Double2DArrays.assertHasDimensions(AssertionInfo info, double[][] actual, int expectedFirstDimension, int expectedSecondDimension)	Asserts that the number of elements in the given array is equal to the expected one.
void	Float2DArrays.assertHasDimensions(AssertionInfo info, float[][] actual, int expectedFirstDimension, int expectedSecondDimension)	Asserts that the number of elements in the given array is equal to the expected one.
void	Int2DArrays.assertHasDimensions(AssertionInfo info, int[][] actual, int expectedFirstDimension, int expectedSecondDimension)	Asserts that the number of elements in the given array is equal to the expected one.
void	Long2DArrays.assertHasDimensions(AssertionInfo info, long[][] actual, int expectedFirstDimension, int expectedSecondDimension)	Asserts that the number of elements in the given array is equal to the expected one.
void	Object2DArrays.assertHasDimensions(AssertionInfo info, ELEMENT[][] actual, int expectedFirstDimension, int expectedSecondDimension)	Asserts that the number of elements in the given array is equal to the expected one.
void	Short2DArrays.assertHasDimensions(AssertionInfo info, short[][] actual, int expectedFirstDimensionSize, int expectedSecondDimensionSize)	Asserts that the number of elements in the given array is equal to the expected one.
<K, V> void	Maps.assertHasEntrySatisfying(AssertionInfo info, Map<K,V> actual, K key, Consumer<? super V> valueRequirements)
<K, V> void	Maps.assertHasEntrySatisfying(AssertionInfo info, Map<K,V> actual, K key, Condition<? super V> valueCondition)
<K, V> void	Maps.assertHasEntrySatisfying(AssertionInfo info, Map<K,V> actual, Condition<? super Map.Entry<K,V>> entryCondition)
<K, V> void	Maps.assertHasEntrySatisfyingConditions(AssertionInfo info, Map<K,V> actual, Condition<? super K> keyCondition, Condition<? super V> valueCondition)
<E> void	ObjectArrays.assertHasExactlyElementsOfTypes(AssertionInfo info, E[] actual, Class<?>... expectedTypes)
void	Files.assertHasExtension(AssertionInfo info, File actual, String expected)	Asserts that the given File has the given extension.
void	Paths.assertHasExtension(AssertionInfo info, Path actual, String expected)
<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	Paths.assertHasFileSystem(AssertionInfo info, Path actual, FileSystem expectedFileSystem)
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 actual Date 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)
void	Strings.assertHasLineCount(AssertionInfo info, CharSequence actual, int expectedLineCount)
void	Throwables.assertHasMessage(AssertionInfo info, Throwable actual, String expectedMessage)	Asserts that the given actual Throwable message is equal to the given one.
void	Throwables.assertHasMessageContaining(AssertionInfo info, Throwable actual, String description)	Asserts that the message of the actual Throwable contains with the given description.
void	Throwables.assertHasMessageContainingAll(AssertionInfo info, Throwable actual, CharSequence... values)	Asserts that the message of the actual Throwable contains with the given values.
void	Throwables.assertHasMessageEndingWith(AssertionInfo info, Throwable actual, String description)	Asserts that the message of the actual Throwable ends with the given description.
void	Throwables.assertHasMessageFindingMatch(AssertionInfo info, Throwable actual, String regex)	Asserts that a sequence of the message of the actual Throwable matches with the given regular expression (see Matcher.find()).
void	Throwables.assertHasMessageMatching(AssertionInfo info, Throwable actual, String regex)
void	Throwables.assertHasMessageMatching(AssertionInfo info, Throwable actual, Pattern regex)	Asserts that the message of the actual Throwable matches with the given regular expression.
void	Throwables.assertHasMessageNotContaining(AssertionInfo info, Throwable actual, String content)	Asserts that the message of the actual Throwable does not contain the given content or is null.
void	Throwables.assertHasMessageNotContainingAny(AssertionInfo info, Throwable actual, CharSequence... values)	Asserts that the message of the actual Throwable does not contain any of the given values or is null.
void	Throwables.assertHasMessageStartingWith(AssertionInfo info, Throwable actual, String description)	Asserts that the message of the actual Throwable starts with the given description.
void	Classes.assertHasMethods(AssertionInfo info, Class<?> actual, String... methods)	Verifies that the actual Class has the methods.
void	Dates.assertHasMillisecond(AssertionInfo info, Date actual, int millisecond)	Verifies that the actual Date millisecond is equal to the given millisecond.
void	Dates.assertHasMinute(AssertionInfo info, Date actual, int minute)	Verifies that the actual Date minute is equal to the given minute.
void	Dates.assertHasMonth(AssertionInfo info, Date actual, int month)	Verifies that the actual Date 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 given File has the given name.
void	Iterators.assertHasNext(AssertionInfo info, Iterator<?> actual)
void	Throwables.assertHasNoCause(AssertionInfo info, Throwable actual)	Asserts that the actual Throwable does not have a cause.
void	Files.assertHasNoExtension(AssertionInfo info, File actual)
void	Paths.assertHasNoExtension(AssertionInfo info, Path actual)
void	Uris.assertHasNoHost(AssertionInfo info, URI actual)
void	Urls.assertHasNoHost(AssertionInfo info, URL actual)
<A> void	Objects.assertHasNoNullFieldsOrPropertiesExcept(AssertionInfo info, A actual, String... propertiesOrFieldsToIgnore)
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 given File 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	Spliterators.assertHasOnlyCharacteristics(AssertionInfo info, Spliterator<?> actual, int... characteristics)	Asserts the given Spliterator has only the given characteristics and no else.
void	Classes.assertHasOnlyDeclaredFields(AssertionInfo info, Class<?> actual, String... expectedFields)	Verifies that the actual Class has the exactly the fields and nothing more.
<E> void	ObjectArrays.assertHasOnlyElementsOfType(AssertionInfo info, E[] actual, Class<?> type)
<E> void	ObjectArrays.assertHasOnlyElementsOfTypes(AssertionInfo info, E[] actual, Class<?>... types)
<A> void	Objects.assertHasOnlyFields(AssertionInfo info, A actual, String... names)
<T> void	Iterables.assertHasOnlyOneElementSatisfying(AssertionInfo info, Iterable<? extends T> actual, Consumer<? super T> consumer)	Asserts that the unique element of the Iterable satisfies the given assertions expressed as a Consumer,
void	Classes.assertHasOnlyPublicFields(AssertionInfo info, Class<?> actual, String... expectedFields)	Verifies that the actual Class has only the fields 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 given File 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 actual Class has the fields.
void	Classes.assertHasPublicMethods(AssertionInfo info, Class<?> actual, String... methods)	Verifies that the actual Class has the public methods.
void	Uris.assertHasQuery(AssertionInfo info, URI actual, String expected)
void	Urls.assertHasQuery(AssertionInfo info, URL actual, String expected)
void	Throwables.assertHasRootCause(AssertionInfo info, Throwable actual)	Asserts that the actual Throwable has a root cause.
void	Throwables.assertHasRootCause(AssertionInfo info, Throwable actual, Throwable expectedRootCause)	Asserts that the actual Throwable has a root cause similar to the given one.
void	Throwables.assertHasRootCauseExactlyInstanceOf(AssertionInfo info, Throwable actual, Class<? extends Throwable> type)	Assert that the root cause of actual Throwable 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 actual Throwable is an instance of the given type.
void	Throwables.assertHasRootCauseMessage(AssertionInfo info, Throwable actual, String expectedMessage)	Asserts that the message of the root cause of the actual Throwable is equal to the given one.
void	Paths.assertHasSameBinaryContentAs(AssertionInfo info, Path actual, Path expected)
void	Objects.assertHasSameClassAs(AssertionInfo info, Object actual, Object other)
void	Arrays2D.assertHasSameDimensionsAs(AssertionInfo info, Object actual, Object other)
void	Boolean2DArrays.assertHasSameDimensionsAs(AssertionInfo info, boolean[][] actual, Object other)	Assert that the actual array has the same dimensions as the other array.
void	Byte2DArrays.assertHasSameDimensionsAs(AssertionInfo info, byte[][] actual, Object other)	Assert that the actual array has the same dimensions as the other array.
void	Char2DArrays.assertHasSameDimensionsAs(AssertionInfo info, char[][] actual, Object other)	Assert that the actual array has the same dimensions as the other array.
void	Double2DArrays.assertHasSameDimensionsAs(AssertionInfo info, double[][] actual, Object other)	Assert that the actual array has the same dimensions as the other array.
void	Float2DArrays.assertHasSameDimensionsAs(AssertionInfo info, float[][] actual, Object other)	Assert that the actual array has the same dimensions as the other array.
void	Int2DArrays.assertHasSameDimensionsAs(AssertionInfo info, int[][] actual, Object other)	Assert that the actual array has the same dimensions as the other array.
void	Long2DArrays.assertHasSameDimensionsAs(AssertionInfo info, long[][] actual, Object other)	Assert that the actual array has the same dimensions as the other array.
void	Object2DArrays.assertHasSameDimensionsAs(AssertionInfo info, ELEMENT[][] actual, Object other)	Assert that the actual array has the same dimensions as the other array.
void	Short2DArrays.assertHasSameDimensionsAs(AssertionInfo info, short[][] actual, Object other)	Assert that the actual array has the same dimensions as the other array.
void	Paths.assertHasSameFileSystemAs(AssertionInfo info, Path actualPath, Path expectedPath)
<A> void	Objects.assertHasSameHashCodeAs(AssertionInfo info, A actual, Object 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 other Iterable.
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 other Iterable.
void	CharArrays.assertHasSameSizeAs(AssertionInfo info, char[] actual, Iterable<?> other)	Assert that the actual array has the same size as the other Iterable.
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 other Iterable.
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 other Iterable.
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 other Iterable.
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 actual Iterable has the same size as the other Iterable.
void	Iterables.assertHasSameSizeAs(AssertionInfo info, Iterable<?> actual, Object other)	Assert that the actual Iterable 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 other Iterable.
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)
void	Maps.assertHasSameSizeAs(AssertionInfo info, Map<?,?> map, Object other)
void	Maps.assertHasSameSizeAs(AssertionInfo info, Map<?,?> map, Map<?,?> other)
void	ObjectArrays.assertHasSameSizeAs(AssertionInfo info, Object[] actual, Iterable<?> other)	Assert that the actual array has the same size as the other Iterable.
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 other Iterable.
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)
void	Strings.assertHasSameSizeAs(AssertionInfo info, CharSequence actual, Object array)
void	Paths.assertHasSameTextualContentAs(AssertionInfo info, Path actual, Charset actualCharset, Path expected, Charset expectedCharset)
void	Dates.assertHasSameTime(AssertionInfo info, Date actual, Date expected)	Verifies that the actual Date has same time as the given Date.
void	BigDecimals.assertHasScale(AssertionInfo info, BigDecimal actual, int expectedScale)
void	Uris.assertHasScheme(AssertionInfo info, URI actual, String scheme)
void	Dates.assertHasSecond(AssertionInfo info, Date actual, int second)	Verifies that the actual Date second is equal to the given second.
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 given Iterable 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)
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	Paths.assertHasSize(AssertionInfo info, Path actual, long expectedSize)
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)
void	BooleanArrays.assertHasSizeBetween(AssertionInfo info, boolean[] actual, int lowerBoundary, int higherBoundary)	Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
void	ByteArrays.assertHasSizeBetween(AssertionInfo info, byte[] actual, int lowerBoundary, int higherBoundary)	Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
void	CharArrays.assertHasSizeBetween(AssertionInfo info, char[] actual, int lowerBoundary, int higherBoundary)	Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
void	DoubleArrays.assertHasSizeBetween(AssertionInfo info, double[] actual, int lowerBoundary, int higherBoundary)	Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
void	FloatArrays.assertHasSizeBetween(AssertionInfo info, float[] actual, int lowerBoundary, int higherBoundary)	Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
void	IntArrays.assertHasSizeBetween(AssertionInfo info, int[] actual, int lowerBoundary, int higherBoundary)	Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
void	Iterables.assertHasSizeBetween(AssertionInfo info, Iterable<?> actual, int lowerBoundary, int higherBoundary)	Asserts that the number of elements in the given Iterable is between the given lower and higher boundary (inclusive).
void	LongArrays.assertHasSizeBetween(AssertionInfo info, long[] actual, int lowerBoundary, int higherBoundary)	Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
void	Maps.assertHasSizeBetween(AssertionInfo info, Map<?,?> actual, int lowerBoundary, int higherBoundary)
void	ObjectArrays.assertHasSizeBetween(AssertionInfo info, Object[] actual, int lowerBoundary, int higherBoundary)	Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
void	ShortArrays.assertHasSizeBetween(AssertionInfo info, short[] actual, int lowerBoundary, int higherBoundary)	Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
void	Strings.assertHasSizeBetween(AssertionInfo info, CharSequence actual, int lowerBoundary, int higherBoundary)
void	BooleanArrays.assertHasSizeGreaterThan(AssertionInfo info, boolean[] actual, int boundary)	Asserts that the number of elements in the given array is greater than the given boundary.
void	ByteArrays.assertHasSizeGreaterThan(AssertionInfo info, byte[] actual, int boundary)	Asserts that the number of elements in the given array is greater than the given boundary.
void	CharArrays.assertHasSizeGreaterThan(AssertionInfo info, char[] actual, int boundary)	Asserts that the number of elements in the given array is greater than the given boundary.
void	DoubleArrays.assertHasSizeGreaterThan(AssertionInfo info, double[] actual, int boundary)	Asserts that the number of elements in the given array is greater than the given boundary.
void	FloatArrays.assertHasSizeGreaterThan(AssertionInfo info, float[] actual, int boundary)	Asserts that the number of elements in the given array is greater than the given boundary.
void	IntArrays.assertHasSizeGreaterThan(AssertionInfo info, int[] actual, int boundary)	Asserts that the number of elements in the given array is greater than the given boundary.
void	Iterables.assertHasSizeGreaterThan(AssertionInfo info, Iterable<?> actual, int boundary)	Asserts that the number of elements in the given Iterable is greater than the boundary.
void	LongArrays.assertHasSizeGreaterThan(AssertionInfo info, long[] actual, int boundary)	Asserts that the number of elements in the given array is greater than the given boundary.
void	Maps.assertHasSizeGreaterThan(AssertionInfo info, Map<?,?> actual, int boundary)
void	ObjectArrays.assertHasSizeGreaterThan(AssertionInfo info, Object[] actual, int boundary)	Asserts that the number of elements in the given array is greater than the given boundary.
void	ShortArrays.assertHasSizeGreaterThan(AssertionInfo info, short[] actual, int boundary)	Asserts that the number of elements in the given array is greater than the given boundary.
void	Strings.assertHasSizeGreaterThan(AssertionInfo info, CharSequence actual, int expectedMinSizeExcluded)
void	BooleanArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info, boolean[] actual, int boundary)	Asserts that the number of elements in the given array is greater than or equal to the given boundary.
void	ByteArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info, byte[] actual, int boundary)	Asserts that the number of elements in the given array is greater than or equal to the given boundary.
void	CharArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info, char[] actual, int boundary)	Asserts that the number of elements in the given array is greater than or equal to the given boundary.
void	DoubleArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info, double[] actual, int boundary)	Asserts that the number of elements in the given array is greater than or equal to the given boundary.
void	FloatArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info, float[] actual, int boundary)	Asserts that the number of elements in the given array is greater than or equal to the given boundary.
void	IntArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info, int[] actual, int boundary)	Asserts that the number of elements in the given array is greater than or equal to the given boundary.
void	Iterables.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info, Iterable<?> actual, int boundary)	Asserts that the number of elements in the given Iterable is greater than or equal to the boundary.
void	LongArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info, long[] actual, int boundary)	Asserts that the number of elements in the given array is greater than or equal to the given boundary.
void	Maps.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info, Map<?,?> actual, int boundary)
void	ObjectArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info, Object[] actual, int boundary)	Asserts that the number of elements in the given array is greater than or equal to the given boundary.
void	ShortArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info, short[] actual, int boundary)	Asserts that the number of elements in the given array is greater than or equal to the given boundary.
void	Strings.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info, CharSequence actual, int expectedMinSizeIncluded)
void	Files.assertHasSizeInBytes(AssertionInfo info, File actual, long expectedSizeInBytes)	Asserts that the given file has the given size in bytes.
void	BooleanArrays.assertHasSizeLessThan(AssertionInfo info, boolean[] actual, int boundary)	Asserts that the number of elements in the given array is less than the given boundary.
void	ByteArrays.assertHasSizeLessThan(AssertionInfo info, byte[] actual, int boundary)	Asserts that the number of elements in the given array is less than the given boundary.
void	CharArrays.assertHasSizeLessThan(AssertionInfo info, char[] actual, int boundary)	Asserts that the number of elements in the given array is less than the given boundary.
void	DoubleArrays.assertHasSizeLessThan(AssertionInfo info, double[] actual, int boundary)	Asserts that the number of elements in the given array is less than the given boundary.
void	FloatArrays.assertHasSizeLessThan(AssertionInfo info, float[] actual, int boundary)	Asserts that the number of elements in the given array is less than the given boundary.
void	IntArrays.assertHasSizeLessThan(AssertionInfo info, int[] actual, int boundary)	Asserts that the number of elements in the given array is less than the given boundary.
void	Iterables.assertHasSizeLessThan(AssertionInfo info, Iterable<?> actual, int boundary)	Asserts that the number of elements in the given Iterable is less than the boundary.
void	LongArrays.assertHasSizeLessThan(AssertionInfo info, long[] actual, int boundary)	Asserts that the number of elements in the given array is less than the given boundary.
void	Maps.assertHasSizeLessThan(AssertionInfo info, Map<?,?> actual, int boundary)
void	ObjectArrays.assertHasSizeLessThan(AssertionInfo info, Object[] actual, int boundary)	Asserts that the number of elements in the given array is less than the given boundary.
void	ShortArrays.assertHasSizeLessThan(AssertionInfo info, short[] actual, int boundary)	Asserts that the number of elements in the given array is less than the given boundary.
void	Strings.assertHasSizeLessThan(AssertionInfo info, CharSequence actual, int expectedMaxSizeExcluded)
void	BooleanArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info, boolean[] actual, int boundary)	Asserts that the number of elements in the given array is less than or equal to the given boundary.
void	ByteArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info, byte[] actual, int boundary)	Asserts that the number of elements in the given array is less than or equal to the given boundary.
void	CharArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info, char[] actual, int boundary)	Asserts that the number of elements in the given array is less than or equal to the given boundary.
void	DoubleArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info, double[] actual, int boundary)	Asserts that the number of elements in the given array is less than or equal to the given boundary.
void	FloatArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info, float[] actual, int boundary)	Asserts that the number of elements in the given array is less than or equal to the given boundary.
void	IntArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info, int[] actual, int boundary)	Asserts that the number of elements in the given array is less than or equal to the given boundary.
void	Iterables.assertHasSizeLessThanOrEqualTo(AssertionInfo info, Iterable<?> actual, int boundary)	Asserts that the number of elements in the given Iterable is less than or equal to the boundary.
void	LongArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info, long[] actual, int boundary)	Asserts that the number of elements in the given array is less than or equal to the given boundary.
void	Maps.assertHasSizeLessThanOrEqualTo(AssertionInfo info, Map<?,?> actual, int boundary)
void	ObjectArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info, Object[] actual, int boundary)	Asserts that the number of elements in the given array is less than or equal to the given boundary.
void	ShortArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info, short[] actual, int boundary)	Asserts that the number of elements in the given array is less than or equal to the given boundary.
void	Strings.assertHasSizeLessThanOrEqualTo(AssertionInfo info, CharSequence actual, int expectedMaxSizeIncluded)
void	Throwables.assertHasStackTraceContaining(AssertionInfo info, Throwable actual, String description)	Asserts that the stack trace of the actual Throwable contains with the given description.
void	Throwables.assertHasSuppressedException(AssertionInfo info, Throwable actual, Throwable expectedSuppressedException)
void	Paths.assertHasTextualContent(AssertionInfo info, Path actual, String expected, Charset charset)
void	Dates.assertHasTime(AssertionInfo info, Date actual, long timestamp)	Verifies that the actual Date 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)
void	Dates.assertHasYear(AssertionInfo info, Date actual, int year)	Verifies that the actual Date 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 given Iterable 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 of Iterables.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 of ObjectArrays.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 of Iterables.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 of ObjectArrays.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 of Iterables.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 of ObjectArrays.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)
protected String	Failures.assertionErrorMessage(AssertionInfo info, ErrorMessageFactory messageFactory)
<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 given List satisfies the given Condition at the given index.
void	Files.assertIsAbsolute(AssertionInfo info, File actual)	Asserts that the given file is an absolute path.
void	Paths.assertIsAbsolute(AssertionInfo info, Path actual)
<T> void	Comparables.assertIsAfter(AssertionInfo info, Comparable<? super T> actual, T other)
void	Dates.assertIsAfter(AssertionInfo info, Date actual, Date other)	Verifies that the actual Date is strictly after the given one.
<T> void	Comparables.assertIsAfterOrEqualTo(AssertionInfo info, Comparable<? super T> actual, T other)
void	Dates.assertIsAfterOrEqualTo(AssertionInfo info, Date actual, Date other)	Verifies that the actual Date is after or equal to the given one.
void	Dates.assertIsAfterYear(AssertionInfo info, Date actual, int year)	Verifies that the actual Date is strictly after the given year.
static void	Arrays.assertIsArray(AssertionInfo info, Object array)
void	Classes.assertIsAssignableFrom(AssertionInfo info, Class<?> actual, Class<?>... others)	Verifies that the actual Class is assignable from all the others classes.
void	Strings.assertIsBase64(AssertionInfo info, String actual)
<T> void	Comparables.assertIsBefore(AssertionInfo info, Comparable<? super T> actual, T other)	Asserts that the actual value is strictly before the other one.
void	Dates.assertIsBefore(AssertionInfo info, Date actual, Date other)	Verifies that the actual Date is strictly before the given one.
<T> void	Comparables.assertIsBeforeOrEqualTo(AssertionInfo info, Comparable<? super T> actual, T other)
void	Dates.assertIsBeforeOrEqualTo(AssertionInfo info, Date actual, Date other)	Verifies that the actual Date is before or equal to the given one.
void	Dates.assertIsBeforeYear(AssertionInfo info, Date actual, int year)	Verifies that the actual Date is strictly before the given year.
<T> void	Comparables.assertIsBetween(AssertionInfo info, Comparable<? super 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 actual Date 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 the Future is cancelled.
void	Paths.assertIsCanonical(AssertionInfo info, Path actual)
void	Dates.assertIsCloseTo(AssertionInfo info, Date actual, Date other, long deltaInMilliseconds)	Verifies that the actual Date 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 with TimeUnit.SECONDS.toMillis(5).
void	Numbers.assertIsCloseTo(AssertionInfo info, NUMBER actual, NUMBER expected, Offset<NUMBER> offset)	Asserts that the actual value is close to the expected one by less than the given 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	Files.assertIsDirectoryContaining(AssertionInfo info, File actual, String syntaxAndPattern)
void	Files.assertIsDirectoryContaining(AssertionInfo info, File actual, Predicate<File> filter)
void	Paths.assertIsDirectoryContaining(AssertionInfo info, Path actual, String syntaxAndPattern)
void	Paths.assertIsDirectoryContaining(AssertionInfo info, Path actual, Predicate<Path> filter)
void	Files.assertIsDirectoryNotContaining(AssertionInfo info, File actual, String syntaxAndPattern)
void	Files.assertIsDirectoryNotContaining(AssertionInfo info, File actual, Predicate<File> filter)
void	Paths.assertIsDirectoryNotContaining(AssertionInfo info, Path actual, String syntaxAndPattern)
void	Paths.assertIsDirectoryNotContaining(AssertionInfo info, Path actual, Predicate<Path> filter)
void	Files.assertIsDirectoryRecursivelyContaining(AssertionInfo info, File actual, String syntaxAndPattern)
void	Files.assertIsDirectoryRecursivelyContaining(AssertionInfo info, File actual, Predicate<File> filter)
void	Paths.assertIsDirectoryRecursivelyContaining(AssertionInfo info, Path actual, String syntaxAndPattern)
void	Paths.assertIsDirectoryRecursivelyContaining(AssertionInfo info, Path actual, Predicate<Path> filter)
void	Futures.assertIsDone(AssertionInfo info, Future<?> actual)	Verifies that the Future is done.
void	Files.assertIsEmptyDirectory(AssertionInfo info, File actual)
void	Paths.assertIsEmptyDirectory(AssertionInfo info, Path actual)
void	Files.assertIsEmptyFile(AssertionInfo info, File actual)	Asserts that the given File is empty (i.e.
void	Paths.assertIsEmptyFile(AssertionInfo info, Path actual)
<A> void	Objects.assertIsEqualToComparingFieldByFieldRecursively(AssertionInfo info, Object actual, Object other, Map<String,Comparator<?>> comparatorByPropertyOrField, TypeComparators comparatorByType)
<A> void	Objects.assertIsEqualToComparingOnlyGivenFields(AssertionInfo info, A actual, A other, Map<String,Comparator<?>> comparatorByPropertyOrField, TypeComparators comparatorByType, String... fields)
<A> void	Objects.assertIsEqualToIgnoringGivenFields(AssertionInfo info, A actual, A other, Map<String,Comparator<?>> comparatorByPropertyOrField, TypeComparators comparatorByType, String... fields)
void	Strings.assertIsEqualToIgnoringNewLines(AssertionInfo info, CharSequence actual, CharSequence expected)
<A> void	Objects.assertIsEqualToIgnoringNullFields(AssertionInfo info, A actual, A other, Map<String,Comparator<?>> comparatorByPropertyOrField, TypeComparators comparatorByType)
void	Strings.assertIsEqualToNormalizingNewlines(AssertionInfo info, CharSequence actual, CharSequence expected)
void	Urls.assertIsEqualToWithSortedQueryParameters(AssertionInfo info, URL actual, URL expected)
void	Dates.assertIsEqualWithPrecision(AssertionInfo info, Date actual, Date other, TimeUnit precision)	Verifies that the actual Date is equal to the given one with precision.
default void	WholeNumbers.assertIsEven(AssertionInfo info, NUMBER actual)	Asserts that the actual value is even.
void	Objects.assertIsExactlyInstanceOf(AssertionInfo info, Object actual, Class<?> type)
void	Files.assertIsExecutable(AssertionInfo info, File actual)	Asserts that the given file can be executed by the application.
void	Paths.assertIsExecutable(AssertionInfo info, Path actual)
void	Iterators.assertIsExhausted(AssertionInfo info, Iterator<?> actual)
void	Files.assertIsFile(AssertionInfo info, File actual)	Asserts that the given file is an existing file.
void	RealNumbers.assertIsFinite(AssertionInfo info, NUMBER actual)
void	Objects.assertIsIn(AssertionInfo info, Object actual, Iterable<?> values)
void	Objects.assertIsIn(AssertionInfo info, Object actual, Object[] values)
void	RealNumbers.assertIsInfinite(AssertionInfo info, NUMBER actual)
void	Dates.assertIsInSameDayAs(AssertionInfo info, Date actual, Date other)	Verifies that actual and given Date 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 given Date 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 given Date 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 given Date 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 given Date are chronologically in the same minute.
void	Dates.assertIsInSameMonthAs(AssertionInfo info, Date actual, Date other)	Verifies that actual and given Date 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 given Date 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 given Date are chronologically in the same second.
void	Dates.assertIsInSameYearAs(AssertionInfo info, Date actual, Date other)	Verifies that actual and given Date are in the same year.
void	Objects.assertIsInstanceOf(AssertionInfo info, Object actual, Class<?> type)
void	Objects.assertIsInstanceOfAny(AssertionInfo info, Object actual, Class<?>[] types)
void	Dates.assertIsInTheFuture(AssertionInfo info, Date actual)	Verifies that the actual Date is strictly in the future.
void	Dates.assertIsInThePast(AssertionInfo info, Date actual)	Verifies that the actual Date is strictly in the past.
void	RealNumbers.assertIsNaN(AssertionInfo info, NUMBER actual)	Verifies that the actual value is equal to NaN. 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	Dates.assertIsNotBetween(AssertionInfo info, Date actual, Date start, Date end, boolean inclusiveStart, boolean inclusiveEnd)	Verifies that the actual Date 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 the Future 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 expected one by less than the given 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 the Future is not done.
void	Files.assertIsNotEmptyDirectory(AssertionInfo info, File actual)
void	Paths.assertIsNotEmptyDirectory(AssertionInfo info, Path actual)
void	Files.assertIsNotEmptyFile(AssertionInfo info, File actual)	Asserts that the given File is not empty (i.e.
void	Paths.assertIsNotEmptyFile(AssertionInfo info, Path actual)
void	Objects.assertIsNotExactlyInstanceOf(AssertionInfo info, Object actual, Class<?> type)
void	RealNumbers.assertIsNotFinite(AssertionInfo info, NUMBER actual)
void	Objects.assertIsNotIn(AssertionInfo info, Object actual, Iterable<?> values)
void	Objects.assertIsNotIn(AssertionInfo info, Object actual, Object[] values)
void	RealNumbers.assertIsNotInfinite(AssertionInfo info, NUMBER actual)
void	Objects.assertIsNotInstanceOf(AssertionInfo info, Object actual, Class<?> type)
void	Objects.assertIsNotInstanceOfAny(AssertionInfo info, Object actual, Class<?>[] types)
void	RealNumbers.assertIsNotNaN(AssertionInfo info, NUMBER actual)	Verifies that the actual value is not equal to NaN.
void	Numbers.assertIsNotNegative(AssertionInfo info, NUMBER actual)	Asserts that the actual value is not negative.
void	Objects.assertIsNotOfAnyClassIn(AssertionInfo info, Object actual, Class<?>[] 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).
default void	WholeNumbers.assertIsOdd(AssertionInfo info, NUMBER actual)	Asserts that the actual value is odd.
void	Objects.assertIsOfAnyClassIn(AssertionInfo info, Object actual, Class<?>[] 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	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)
void	BooleanArrays.assertIsSorted(AssertionInfo info, boolean[] actual)	Concrete implementation of ArraySortedAssert.isSorted().
void	ByteArrays.assertIsSorted(AssertionInfo info, byte[] actual)	Concrete implementation of ArraySortedAssert.isSorted().
void	CharArrays.assertIsSorted(AssertionInfo info, char[] actual)	Concrete implementation of ArraySortedAssert.isSorted().
void	DoubleArrays.assertIsSorted(AssertionInfo info, double[] actual)	Concrete implementation of ArraySortedAssert.isSorted().
void	FloatArrays.assertIsSorted(AssertionInfo info, float[] actual)	Concrete implementation of ArraySortedAssert.isSorted().
void	IntArrays.assertIsSorted(AssertionInfo info, int[] actual)	Concrete implementation of ArraySortedAssert.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 of ArraySortedAssert.isSorted().
void	ObjectArrays.assertIsSorted(AssertionInfo info, Object[] actual)	Concrete implementation of ArraySortedAssert.isSorted().
void	ShortArrays.assertIsSorted(AssertionInfo info, short[] actual)	Concrete implementation of ArraySortedAssert.isSorted().
void	BooleanArrays.assertIsSortedAccordingToComparator(AssertionInfo info, boolean[] actual, Comparator<? super Boolean> comparator)	Concrete implementation of ArraySortedAssert.isSortedAccordingTo(Comparator).
void	ByteArrays.assertIsSortedAccordingToComparator(AssertionInfo info, byte[] actual, Comparator<? super Byte> comparator)	Concrete implementation of ArraySortedAssert.isSortedAccordingTo(Comparator).
void	CharArrays.assertIsSortedAccordingToComparator(AssertionInfo info, char[] actual, Comparator<? super Character> comparator)	Concrete implementation of ArraySortedAssert.isSortedAccordingTo(Comparator).
void	DoubleArrays.assertIsSortedAccordingToComparator(AssertionInfo info, double[] actual, Comparator<? super Double> comparator)	Concrete implementation of ArraySortedAssert.isSortedAccordingTo(Comparator).
void	FloatArrays.assertIsSortedAccordingToComparator(AssertionInfo info, float[] actual, Comparator<? super Float> comparator)	Concrete implementation of ArraySortedAssert.isSortedAccordingTo(Comparator).
void	IntArrays.assertIsSortedAccordingToComparator(AssertionInfo info, int[] actual, Comparator<? super Integer> comparator)	Concrete implementation of ArraySortedAssert.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 of ArraySortedAssert.isSortedAccordingTo(Comparator).
<E> void	ObjectArrays.assertIsSortedAccordingToComparator(AssertionInfo info, E[] actual, Comparator<? super E> comparator)	Concrete implementation of ArraySortedAssert.isSortedAccordingTo(Comparator).
void	ShortArrays.assertIsSortedAccordingToComparator(AssertionInfo info, short[] actual, Comparator<? super Short> comparator)	Concrete implementation of ArraySortedAssert.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 actual Iterable is a subset of values Iterable.
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 actual Date 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).
<T> void	Comparables.assertLessThan(AssertionInfo info, Comparable<? super T> actual, T other)	Asserts that the actual value is less than the other one.
<T> void	Comparables.assertLessThanOrEqualTo(AssertionInfo info, Comparable<? super T> actual, T other)
void	Characters.assertLowerCase(AssertionInfo info, Character actual)	Asserts that the actual value is a lowercase character.
void	Strings.assertLowerCase(AssertionInfo info, CharSequence actual)
void	Strings.assertMatches(AssertionInfo info, CharSequence actual, CharSequence regex)
void	Strings.assertMatches(AssertionInfo info, CharSequence actual, Matcher matcher)
void	Strings.assertMatches(AssertionInfo info, CharSequence actual, Pattern pattern)
void	Strings.assertMixedCase(AssertionInfo info, CharSequence actual)
<E> void	Iterables.assertNoneMatch(AssertionInfo info, Iterable<? extends E> actual, Predicate<? super E> predicate, PredicateDescription predicateDescription)
<E> void	Iterables.assertNoneSatisfy(AssertionInfo info, Iterable<? extends E> actual, Consumer<? super E> restrictions)
<K, V> void	Maps.assertNoneSatisfy(AssertionInfo info, Map<K,V> actual, BiConsumer<? super K,? super V> entryRequirements)
void	Arrays2D.assertNotEmpty(AssertionInfo info, Failures failures, Object array)
void	Boolean2DArrays.assertNotEmpty(AssertionInfo info, boolean[][] actual)	Asserts that the given array is not empty.
void	BooleanArrays.assertNotEmpty(AssertionInfo info, boolean[] actual)	Asserts that the given array is not empty.
void	Byte2DArrays.assertNotEmpty(AssertionInfo info, byte[][] 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	Char2DArrays.assertNotEmpty(AssertionInfo info, char[][] 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	Double2DArrays.assertNotEmpty(AssertionInfo info, double[][] 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	Float2DArrays.assertNotEmpty(AssertionInfo info, float[][] 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	Int2DArrays.assertNotEmpty(AssertionInfo info, int[][] 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 given Iterable is not empty.
void	Long2DArrays.assertNotEmpty(AssertionInfo info, long[][] actual)	Asserts that the given array 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)
void	Object2DArrays.assertNotEmpty(AssertionInfo info, ELEMENT[][] actual)	Asserts that the given array is not empty.
void	ObjectArrays.assertNotEmpty(AssertionInfo info, Object[] actual)	Asserts that the given array is not empty.
void	Short2DArrays.assertNotEmpty(AssertionInfo info, short[][] 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)
<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)
<T> void	Comparables.assertNotEqualByComparison(AssertionInfo info, Comparable<? super T> actual, T other)	Asserts that two Comparables are not equal by invoking Comparable.compareTo(Object) . Note that it does not rely on the custom Comparables.comparisonStrategy if one has been set.
void	Strings.assertNotEqualsIgnoringCase(AssertionInfo info, CharSequence actual, CharSequence expected)
void	Strings.assertNotEqualsIgnoringWhitespace(AssertionInfo info, CharSequence actual, CharSequence expected)
void	Strings.assertNotEqualsNormalizingWhitespace(AssertionInfo info, CharSequence actual, CharSequence expected)
protected static <T> void	Comparables.assertNotNull(AssertionInfo info, T actual)
void	Objects.assertNotNull(AssertionInfo info, Object actual)
void	Objects.assertNotNull(AssertionInfo info, Object actual, String label)
void	Objects.assertNotSame(AssertionInfo info, Object actual, Object other)
void	Objects.assertNull(AssertionInfo info, Object actual)
void	Arrays2D.assertNullOrEmpty(AssertionInfo info, Failures failures, Object array)
void	Boolean2DArrays.assertNullOrEmpty(AssertionInfo info, boolean[][] actual)	Asserts that the given array is null or empty.
void	BooleanArrays.assertNullOrEmpty(AssertionInfo info, boolean[] actual)	Asserts that the given array is null or empty.
void	Byte2DArrays.assertNullOrEmpty(AssertionInfo info, byte[][] actual)	Asserts that the given array is null or empty.
void	ByteArrays.assertNullOrEmpty(AssertionInfo info, byte[] actual)	Asserts that the given array is null or empty.
void	Char2DArrays.assertNullOrEmpty(AssertionInfo info, char[][] actual)	Asserts that the given array is null or empty.
void	CharArrays.assertNullOrEmpty(AssertionInfo info, char[] actual)	Asserts that the given array is null or empty.
void	Double2DArrays.assertNullOrEmpty(AssertionInfo info, double[][] actual)	Asserts that the given array is null or empty.
void	DoubleArrays.assertNullOrEmpty(AssertionInfo info, double[] actual)	Asserts that the given array is null or empty.
void	Float2DArrays.assertNullOrEmpty(AssertionInfo info, float[][] actual)	Asserts that the given array is null or empty.
void	FloatArrays.assertNullOrEmpty(AssertionInfo info, float[] actual)	Asserts that the given array is null or empty.
void	Int2DArrays.assertNullOrEmpty(AssertionInfo info, int[][] actual)	Asserts that the given array is null or empty.
void	IntArrays.assertNullOrEmpty(AssertionInfo info, int[] actual)	Asserts that the given array is null or empty.
void	Iterables.assertNullOrEmpty(AssertionInfo info, Iterable<?> actual)	Asserts that the given Iterable is null or empty.
void	Long2DArrays.assertNullOrEmpty(AssertionInfo info, long[][] actual)	Asserts that the given array is null or empty.
void	LongArrays.assertNullOrEmpty(AssertionInfo info, long[] actual)	Asserts that the given array is null or empty.
void	Maps.assertNullOrEmpty(AssertionInfo info, Map<?,?> actual)
void	Object2DArrays.assertNullOrEmpty(AssertionInfo info, ELEMENT[][] actual)	Asserts that the given array is null or empty.
void	ObjectArrays.assertNullOrEmpty(AssertionInfo info, Object[] actual)	Asserts that the given array is null or empty.
void	Short2DArrays.assertNullOrEmpty(AssertionInfo info, short[][] actual)	Asserts that the given array is null or empty.
void	ShortArrays.assertNullOrEmpty(AssertionInfo info, short[] actual)	Asserts that the given array is null or empty.
void	Strings.assertNullOrEmpty(AssertionInfo info, CharSequence actual)
void	Arrays2D.assertNumberOfRows(AssertionInfo info, Failures failures, Object array, int expectedSize)
void	Boolean2DArrays.assertNumberOfRows(AssertionInfo info, boolean[][] actual, int expectedNumberOfRows)	Asserts that the number of rows in the given array is equal to the expected one.
void	Byte2DArrays.assertNumberOfRows(AssertionInfo info, byte[][] actual, int expectedNumberOfRows)	Asserts that the number of rows in the given array is equal to the expected one.
void	Char2DArrays.assertNumberOfRows(AssertionInfo info, char[][] actual, int expectedNumberOfRows)	Asserts that the number of rows in the given array is equal to the expected one.
void	Double2DArrays.assertNumberOfRows(AssertionInfo info, double[][] actual, int expectedNumberOfRows)	Asserts that the number of rows in the given array is equal to the expected one.
void	Float2DArrays.assertNumberOfRows(AssertionInfo info, float[][] actual, int expectedNumberOfRows)	Asserts that the number of rows in the given array is equal to the expected one.
void	Int2DArrays.assertNumberOfRows(AssertionInfo info, int[][] actual, int expectedNumberOfRows)	Asserts that the number of rows in the given array is equal to the expected one.
void	Long2DArrays.assertNumberOfRows(AssertionInfo info, long[][] actual, int expectedNumberOfRows)	Asserts that the number of rows in the given array is equal to the expected one.
void	Object2DArrays.assertNumberOfRows(AssertionInfo info, ELEMENT[][] actual, int expectedNumberOfRows)	Asserts that the number of rows in the given array is equal to the expected one.
void	Short2DArrays.assertNumberOfRows(AssertionInfo info, short[][] actual, int expectedNumberOfRows)	Asserts that the number of rows in the given array is equal to the expected one.
void	Objects.assertSame(AssertionInfo info, Object actual, Object expected)
void	Files.assertSameBinaryContentAs(AssertionInfo info, File actual, File expected)	Asserts that the given files have the same binary content.
void	Files.assertSameContentAs(AssertionInfo info, File actual, Charset actualCharset, File expected, Charset expectedCharset)	Asserts that the given files have same content.
<T> void	Conditions.assertSatisfies(AssertionInfo info, T actual, Condition<? super T> condition)
<E> void	Iterables.assertSatisfiesExactly(AssertionInfo info, Iterable<? extends E> actual, Consumer<? super E>[] allRequirements)
<E> void	Iterables.assertSatisfiesExactlyInAnyOrder(AssertionInfo info, Iterable<? extends E> actual, Consumer<? super E>[] consumers)
<E> void	Iterables.assertSatisfiesOnlyOnce(AssertionInfo info, Iterable<? extends E> actual, Consumer<? super E> requirements)
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 given Iterable 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 other)
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)
void	Strings.assertStartsWithIgnoringCase(AssertionInfo info, CharSequence actual, CharSequence prefix)
void	Paths.assertStartsWithRaw(AssertionInfo info, Path actual, Path other)
<RESULT> RESULT	Futures.assertSucceededWithin(AssertionInfo info, Future<RESULT> actual, long timeout, TimeUnit unit)
<RESULT> RESULT	Futures.assertSucceededWithin(AssertionInfo info, Future<RESULT> actual, Duration timeout)
void	Characters.assertUpperCase(AssertionInfo info, Character actual)	Asserts that the actual value is a uppercase character.
void	Strings.assertUpperCase(AssertionInfo info, CharSequence actual)
void	Strings.assertXmlEqualsTo(AssertionInfo info, CharSequence actualXml, CharSequence expectedXml)
<ACTUAL_ELEMENT, OTHER_ELEMENT> void	Iterables.assertZipSatisfy(AssertionInfo info, Iterable<? extends ACTUAL_ELEMENT> actual, Iterable<OTHER_ELEMENT> other, BiConsumer<? super ACTUAL_ELEMENT,OTHER_ELEMENT> zipRequirements)
static void	CommonValidations.checkLineCounts(Object actual, int lineCountOfActual, int lineCountOfOther, AssertionInfo info)
static void	CommonValidations.checkSizeBetween(Object actual, int lowerBoundary, int higherBoundary, int sizeOfActual, AssertionInfo info)
static void	CommonValidations.checkSizeGreaterThan(Object actual, int boundary, int sizeOfActual, AssertionInfo info)
static void	CommonValidations.checkSizeGreaterThanOrEqualTo(Object actual, int boundary, int sizeOfActual, AssertionInfo info)
static void	CommonValidations.checkSizeLessThan(Object actual, int boundary, int sizeOfActual, AssertionInfo info)
static void	CommonValidations.checkSizeLessThanOrEqualTo(Object actual, int boundary, int sizeOfActual, AssertionInfo info)
static void	CommonValidations.checkSizes(Object actual, int sizeOfActual, int sizeOfOther, AssertionInfo info)
static void	Strings.doCommonCheckForCharSequence(AssertionInfo info, CharSequence actual, CharSequence[] sequence)
static void	CommonValidations.failIfEmptySinceActualIsNotEmpty(AssertionInfo info, Failures failures, Object actual, Object values)
AssertionError	Failures.failure(AssertionInfo info, AssertionErrorFactory factory)	Creates a AssertionError following this pattern: creates a AssertionError using overridingErrorMessage() as the error message if such value is not null, or uses the given AssertionErrorFactory to create an AssertionError, prepending the value of description() to the error message
AssertionError	Failures.failure(AssertionInfo info, ErrorMessageFactory messageFactory)	Creates a AssertionError following this pattern: creates a AssertionError using overridingErrorMessage() as the error message if such value is not null, or uses the given ErrorMessageFactory to create the detail message of the AssertionError, prepending the value of description() to the error message
AssertionError	Failures.failure(AssertionInfo info, ErrorMessageFactory messageFactory, Object actual, Object expected)
AssertionError	Failures.failureIfErrorMessageIsOverridden(AssertionInfo info)
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 actual Date is equal to the given date by comparing their time.
<T> void	Lists.satisfies(AssertionInfo info, List<? extends T> actual, Consumer<? super T> requirements, Index index)