Uses of Interface
org.assertj.core.api.AssertionInfo
Packages that use AssertionInfo
-
Uses of AssertionInfo in org.assertj.core.api
Classes in org.assertj.core.api that implement AssertionInfoModifier and TypeClassDescriptionclass
Writable information about an assertion.Methods in org.assertj.core.api with parameters of type AssertionInfoModifier and TypeMethodDescriptionprivate AssertionError
ListAssert.actualDoesNotStartWithSequence
(AssertionInfo info, Object[] sequence) private static void
AbstractInstantAssert.assertNotNull
(AssertionInfo info, Instant actual) -
Uses of AssertionInfo in org.assertj.core.error
Methods in org.assertj.core.error with parameters of type AssertionInfoModifier and TypeMethodDescriptionprivate static String
ElementsShouldSatisfy.describe
(Map.Entry<Integer, UnsatisfiedRequirement> requirementsAtIndex, AssertionInfo info) UnsatisfiedRequirement.describe
(int index, AssertionInfo info) UnsatisfiedRequirement.describe
(AssertionInfo info) private static String
ZippedElementsShouldSatisfy.describe
(AssertionInfo info, List<ZippedElementsShouldSatisfy.ZipSatisfyError> zipSatisfyErrors) static String
ZippedElementsShouldSatisfy.ZipSatisfyError.describe
(AssertionInfo info, ZippedElementsShouldSatisfy.ZipSatisfyError satisfyError) private static String
ElementsShouldSatisfy.describeErrors
(List<UnsatisfiedRequirement> elementsNotSatisfyingRequirements, AssertionInfo info) private static String
ElementsShouldSatisfy.describeErrors
(Map<Integer, UnsatisfiedRequirement> unsatisfiedRequirements, AssertionInfo info) 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) Constructors in org.assertj.core.error with parameters of type AssertionInfoModifierConstructorDescriptionprivate
ElementsShouldSatisfy
(String message, Object actual, List<UnsatisfiedRequirement> elementsNotSatisfyingRequirements, AssertionInfo info) private
ElementsShouldSatisfy
(String message, Object actual, Map<Integer, UnsatisfiedRequirement> unsatisfiedRequirements, AssertionInfo info) private
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 AssertionInfoModifier and TypeMethodDescriptionprivate AssertionError
Iterables.actualContainsSubsequence
(AssertionInfo info, Iterable<?> actual, Object[] subsequence, int index) private AssertionError
Iterables.actualDoesContainSequence
(AssertionInfo info, Iterable<?> actual, Object[] sequence, int index) private AssertionError
Iterables.actualDoesNotContainSequence
(AssertionInfo info, Iterable<?> actual, Object[] sequence) private AssertionError
Iterables.actualDoesNotContainSubsequence
(AssertionInfo info, Iterable<?> actual, Object[] subsequence, int subsequenceIndex) private AssertionError
Iterables.actualDoesNotEndWithSequence
(AssertionInfo info, Iterable<?> actual, Object[] sequence) private AssertionError
Iterables.actualDoesNotStartWithSequence
(AssertionInfo info, Iterable<?> actual, Object[] sequence) private boolean
Dates.actualIsBetweenGivenPeriod
(AssertionInfo info, Date actual, Date start, Date end, boolean inclusiveStart, boolean inclusiveEnd) private boolean
Objects.actualIsExactlyInstanceOfType
(Object actual, Class<?> expectedType, AssertionInfo info) private AssertionError
Arrays.arrayDoesNotEndWithSequence
(AssertionInfo info, Failures failures, Object array, Object sequence) private AssertionError
Arrays.arrayDoesNotStartWithSequence
(AssertionInfo info, Failures failures, Object array, Object sequence) <E> void
Iterables.assertAllMatch
(AssertionInfo info, Iterable<? extends E> actual, Predicate<? super E> predicate, PredicateDescription predicateDescription) <E> void
Iterables.assertAllSatisfy
(AssertionInfo info, Iterable<? extends E> actual, Consumer<? super E> requirements) <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 givenIterable
satisfies the given condition.<E> void
ObjectArrays.assertAre
(AssertionInfo info, E[] actual, Condition<? super E> condition) Assert that each element of given array satisfies the given condition.<E> void
Arrays.assertAreAtLeast
(AssertionInfo info, Failures failures, Conditions conditions, Object array, int times, Condition<E> condition) <E> void
Iterables.assertAreAtLeast
(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition) Assert that there are at least n elements in the actualIterable
satisfying the given condition.<E> void
ObjectArrays.assertAreAtLeast
(AssertionInfo info, E[] actual, int n, Condition<? super E> condition) Assert that there are at least n array elements satisfying the given condition.<E> void
Arrays.assertAreAtMost
(AssertionInfo info, Failures failures, Conditions conditions, Object array, int times, Condition<E> condition) <E> void
Iterables.assertAreAtMost
(AssertionInfo info, Iterable<? extends E> actual, int n, Condition<? super E> condition) Assert that there are at most n elements in the actualIterable
satisfying the given condition.<E> void
ObjectArrays.assertAreAtMost
(AssertionInfo info, E[] actual, int n, Condition<? super E> condition) Assert that there are at most n array elements satisfying the given condition.<E> void
Arrays.assertAreExactly
(AssertionInfo info, Failures failures, Conditions conditions, Object array, int times, Condition<E> condition) <E> void
Iterables.assertAreExactly
(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition) Verifies that there are exactly n elements in the actualIterable
satisfying the given condition.<E> void
ObjectArrays.assertAreExactly
(AssertionInfo info, E[] actual, int n, Condition<? super E> condition) Verifies that there are exactly n array elements satisfying the given condition.<E> void
Arrays.assertAreNot
(AssertionInfo info, Failures failures, Conditions conditions, Object array, Condition<E> condition) <E> void
Iterables.assertAreNot
(AssertionInfo info, Iterable<? extends E> actual, Condition<? super E> condition) Assert that each element of givenIterable
not satisfies the given condition.<E> void
ObjectArrays.assertAreNot
(AssertionInfo info, E[] actual, Condition<? super E> condition) Assert that each element of given array not satisfies the given condition.void
Strings.assertBlank
(AssertionInfo info, CharSequence actual) Asserts that the givenCharSequence
isNull
, empty or consists of one or more whitespace characters.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.void
Arrays.assertContains
(AssertionInfo info, Failures failures, Object actual, Object values) (package private) void
Arrays.assertContains
(AssertionInfo info, Failures failures, Object array, Object value, Index index) void
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 givenIterable
contains the given values, in any order.void
Lists.assertContains
(AssertionInfo info, List<?> actual, Object value, Index index) Verifies that the givenList
contains the given object at the given index.void
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) Verifies that the givenCharSequence
contains the given strings.(package private) void
Arrays.assertcontainsAll
(AssertionInfo info, Failures failures, Object array, Iterable<?> iterable) void
Iterables.assertContainsAll
(AssertionInfo info, Iterable<?> actual, Iterable<?> other) Asserts that the givenIterable
contains all the elements of the otherIterable
, in any order.<E> void
ObjectArrays.assertContainsAll
(AssertionInfo info, E[] actual, Iterable<? extends E> other) Asserts that the given array contains all the elements of the givenIterable
, in any order.<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 actualClass
contains the givenAnnotation
s.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 givenIterable
contains at least one of the givenvalues
.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) (package private) void
Arrays.assertContainsExactly
(AssertionInfo info, Failures failures, Object actual, Object values) void
BooleanArrays.assertContainsExactly
(AssertionInfo info, boolean[] actual, boolean[] values) void
ByteArrays.assertContainsExactly
(AssertionInfo info, byte[] actual, byte[] values) void
ByteArrays.assertContainsExactly
(AssertionInfo info, byte[] actual, int[] values) void
CharArrays.assertContainsExactly
(AssertionInfo info, char[] actual, char[] values) void
DoubleArrays.assertContainsExactly
(AssertionInfo info, double[] actual, double[] values) void
FloatArrays.assertContainsExactly
(AssertionInfo info, float[] actual, float[] values) void
IntArrays.assertContainsExactly
(AssertionInfo info, int[] actual, int[] values) void
Iterables.assertContainsExactly
(AssertionInfo info, Iterable<?> actual, Object[] values) Asserts that the givenIterable
contains exactly the given values and nothing else, in order.void
LongArrays.assertContainsExactly
(AssertionInfo info, long[] actual, long[] values) <K,
V> void Maps.assertContainsExactly
(AssertionInfo info, Map<K, V> actual, Map.Entry<? extends K, ? extends V>[] entries) void
ObjectArrays.assertContainsExactly
(AssertionInfo info, Object[] actual, Object[] values) void
ShortArrays.assertContainsExactly
(AssertionInfo info, short[] actual, short[] values) (package private) void
Arrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, Failures failures, Object actual, Object values) void
BooleanArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, boolean[] actual, boolean[] values) void
ByteArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, byte[] actual, byte[] values) void
ByteArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, byte[] actual, int[] values) void
CharArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, char[] actual, char[] values) void
DoubleArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, double[] actual, double[] values) void
FloatArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, float[] actual, float[] values) void
IntArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, int[] actual, int[] values) void
Iterables.assertContainsExactlyInAnyOrder
(AssertionInfo info, Iterable<?> actual, Object[] values) void
LongArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, long[] actual, long[] values) void
ObjectArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, Object[] actual, Object[] values) void
ShortArrays.assertContainsExactlyInAnyOrder
(AssertionInfo info, short[] actual, short[] values) void
Strings.assertContainsIgnoringCase
(AssertionInfo info, CharSequence actual, CharSequence sequence) Verifies that the givenCharSequence
contains the given sequence, ignoring case considerations.void
Strings.assertContainsIgnoringNewLines
(AssertionInfo info, CharSequence actual, CharSequence... values) Verifies the givenCharSequence
has the strings, ignoring newlines.void
Strings.assertContainsIgnoringWhitespaces
(AssertionInfo info, CharSequence actual, CharSequence... values) Verifies that the givenCharSequence
contains the given strings, ignoring whitespaces.<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) (package private) void
Arrays.assertContainsNull
(AssertionInfo info, Failures failures, Object array) void
Iterables.assertContainsNull
(AssertionInfo info, Iterable<?> actual) Asserts that the givenIterable
contains at least a null element.void
ObjectArrays.assertContainsNull
(AssertionInfo info, Object[] actual) Asserts that the given array contains at least a null element.(package private) void
Arrays.assertContainsOnly
(AssertionInfo info, Failures failures, Object actual, Object values) void
BooleanArrays.assertContainsOnly
(AssertionInfo info, boolean[] actual, boolean[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
ByteArrays.assertContainsOnly
(AssertionInfo info, byte[] actual, byte[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
ByteArrays.assertContainsOnly
(AssertionInfo info, byte[] actual, int[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
CharArrays.assertContainsOnly
(AssertionInfo info, char[] actual, char[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
DoubleArrays.assertContainsOnly
(AssertionInfo info, double[] actual, double[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
FloatArrays.assertContainsOnly
(AssertionInfo info, float[] actual, float[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
IntArrays.assertContainsOnly
(AssertionInfo info, int[] actual, int[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
Iterables.assertContainsOnly
(AssertionInfo info, Iterable<?> actual, Object[] expectedValues) Asserts that the givenIterable
contains only the given values and nothing else, in any order.void
LongArrays.assertContainsOnly
(AssertionInfo info, long[] actual, long[] values) Asserts that the given array contains only the given values and nothing else, in any order.<K,
V> void Maps.assertContainsOnly
(AssertionInfo info, Map<K, V> actual, Map.Entry<? extends K, ? extends V>[] entries) void
ObjectArrays.assertContainsOnly
(AssertionInfo info, Object[] actual, Object[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
ShortArrays.assertContainsOnly
(AssertionInfo info, short[] actual, short[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
Strings.assertContainsOnlyDigits
(AssertionInfo info, CharSequence actual) Verifies that the givenCharSequence
contains only digits.<K,
V> void Maps.assertContainsOnlyKeys
(AssertionInfo info, Map<K, V> actual, Iterable<? extends K> keys) private <K,
V> void Maps.assertContainsOnlyKeys
(AssertionInfo info, Map<K, V> actual, String placeholderForErrorMessages, K[] keys) <K,
V> void Maps.assertContainsOnlyKeys
(AssertionInfo info, Map<K, V> actual, K[] keys) (package private) void
Arrays.assertContainsOnlyNulls
(AssertionInfo info, Failures failures, Object[] actual) void
Iterables.assertContainsOnlyNulls
(AssertionInfo info, Iterable<?> actual) Asserts that the givenIterable
contains only null elements and nothing else.void
ObjectArrays.assertContainsOnlyNulls
(AssertionInfo info, Object[] actual) Asserts that the given array contains only null elements.(package private) void
Arrays.assertContainsOnlyOnce
(AssertionInfo info, Failures failures, Object actual, Object values) void
BooleanArrays.assertContainsOnlyOnce
(AssertionInfo info, boolean[] actual, boolean[] values) Asserts that the given array contains only once the given values.void
ByteArrays.assertContainsOnlyOnce
(AssertionInfo info, byte[] actual, byte[] values) Asserts that the given array contains only once the given values.void
ByteArrays.assertContainsOnlyOnce
(AssertionInfo info, byte[] actual, int[] values) Asserts that the given array contains only once the given values.void
CharArrays.assertContainsOnlyOnce
(AssertionInfo info, char[] actual, char[] values) Asserts that the given array contains only once the given values.void
DoubleArrays.assertContainsOnlyOnce
(AssertionInfo info, double[] actual, double[] values) Asserts that the given array contains only once the given values.void
FloatArrays.assertContainsOnlyOnce
(AssertionInfo info, float[] actual, float[] values) Asserts that the given array contains only once the given values.void
IntArrays.assertContainsOnlyOnce
(AssertionInfo info, int[] actual, int[] values) Asserts that the given array contains only once the given values.void
Iterables.assertContainsOnlyOnce
(AssertionInfo info, Iterable<?> actual, Object[] values) Asserts that the givenIterable
contains the given values and only once.void
LongArrays.assertContainsOnlyOnce
(AssertionInfo info, long[] actual, long[] values) Asserts that the given array contains only once the given values.void
ObjectArrays.assertContainsOnlyOnce
(AssertionInfo info, Object[] actual, Object[] values) Asserts that the given array contains only once the given values.void
ShortArrays.assertContainsOnlyOnce
(AssertionInfo info, short[] actual, short[] values) Asserts that the given array contains only once the given values.void
Strings.assertContainsOnlyOnce
(AssertionInfo info, CharSequence actual, CharSequence sequence) Verifies that actualCharSequence
s contains only once the given sequence.void
Strings.assertContainsOnlyWhitespaces
(AssertionInfo info, CharSequence actual) Asserts that the givenCharSequence
consists of one or more whitespace characters.void
Strings.assertContainsPattern
(AssertionInfo info, CharSequence actual, CharSequence regex) Verifies that the givenCharSequence
contains the given regular expression.void
Strings.assertContainsPattern
(AssertionInfo info, CharSequence actual, Matcher matcher) Verifies that the givenCharSequence
contains the given regular expression.void
Strings.assertContainsPattern
(AssertionInfo info, CharSequence actual, Pattern pattern) Verifies that the givenCharSequence
contains the given regular expression.(package private) void
Arrays.assertContainsSequence
(AssertionInfo info, Failures failures, Object actual, Object sequence) void
BooleanArrays.assertContainsSequence
(AssertionInfo info, boolean[] actual, boolean[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
ByteArrays.assertContainsSequence
(AssertionInfo info, byte[] actual, byte[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
ByteArrays.assertContainsSequence
(AssertionInfo info, byte[] actual, int[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
CharArrays.assertContainsSequence
(AssertionInfo info, char[] actual, char[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
DoubleArrays.assertContainsSequence
(AssertionInfo info, double[] actual, double[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
FloatArrays.assertContainsSequence
(AssertionInfo info, float[] actual, float[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
IntArrays.assertContainsSequence
(AssertionInfo info, int[] actual, int[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
Iterables.assertContainsSequence
(AssertionInfo info, Iterable<?> actual, Object[] sequence) Verifies that the given
contains the given sequence of objects, without any other objects between them.Iterable
void
LongArrays.assertContainsSequence
(AssertionInfo info, long[] actual, long[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
ObjectArrays.assertContainsSequence
(AssertionInfo info, Object[] actual, Object[] sequence) Verifies that the given array contains the given sequence of objects, without any other objects between them.void
ShortArrays.assertContainsSequence
(AssertionInfo info, short[] actual, short[] sequence) Verifies that the given array contains the given sequence of values, without any other values between them.void
Strings.assertContainsSequence
(AssertionInfo info, CharSequence actual, CharSequence[] sequence) Verifies that the given charSequence contains the given sequence of charSequence, without any other charSequences between them.(package private) void
Arrays.assertContainsSubsequence
(AssertionInfo info, Failures failures, Object actual, Object subsequence) void
BooleanArrays.assertContainsSubsequence
(AssertionInfo info, boolean[] actual, boolean[] subsequence) Verifies that the given array contains the given subsequence of values (possibly with other values between them).void
ByteArrays.assertContainsSubsequence
(AssertionInfo info, byte[] actual, byte[] subsequence) Verifies that the given array contains the given sequence of values (possibly with other values between them).void
ByteArrays.assertContainsSubsequence
(AssertionInfo info, byte[] actual, int[] subsequence) Verifies that the given array contains the given sequence of values (possibly with other values between them).void
CharArrays.assertContainsSubsequence
(AssertionInfo info, char[] actual, char[] subsequence) Verifies that the given array contains the given subsequence of values (possibly with other values between them).void
DoubleArrays.assertContainsSubsequence
(AssertionInfo info, double[] actual, double[] subsequence) Verifies that the given array contains the given subsequence of values (possibly with other values between them).void
FloatArrays.assertContainsSubsequence
(AssertionInfo info, float[] actual, float[] subsequence) Verifies that the given array contains the given subsequence of values (possibly with other values between them).void
IntArrays.assertContainsSubsequence
(AssertionInfo info, int[] actual, int[] subsequence) Verifies that the given array contains the given subsequence of values (possibly with other values between them).void
Iterables.assertContainsSubsequence
(AssertionInfo info, Iterable<?> actual, Object[] subsequence) Verifies that the given
contains the given subsequence of objects (possibly with other values between them).Iterable
void
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) Verifies that the actualCharSequence
contains all the given values in the given order (possibly with other values between them).<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
Strings.assertContainsWhitespaces
(AssertionInfo info, CharSequence actual) Asserts that the givenCharSequence
contains one or more whitespace characters.(package private) void
Arrays.assertDoesNotContain
(AssertionInfo info, Failures failures, Object array, Object values) (package private) void
Arrays.assertDoesNotContain
(AssertionInfo info, Failures failures, Object array, Object value, Index index) void
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 givenIterable
does not contain the given values.void
Lists.assertDoesNotContain
(AssertionInfo info, List<?> actual, Object value, Index index) Verifies that the givenList
does not contain the given object at the given index.void
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) Verifies that the givenCharSequence
does not contain any one of the given values.<T> void
Iterables.assertDoesNotContainAnyElementsOf
(AssertionInfo info, Iterable<? extends T> actual, Iterable<? extends T> iterable) Asserts that the givenIterable
does not contain the given values.<T> void
ObjectArrays.assertDoesNotContainAnyElementsOf
(AssertionInfo info, Object[] actual, Iterable<? extends T> iterable) void
Strings.assertDoesNotContainAnyWhitespaces
(AssertionInfo info, CharSequence actual) Asserts that the givenCharSequence
isNull
, empty or contains only non-whitespace characters.void
Strings.assertDoesNotContainIgnoringCase
(AssertionInfo info, CharSequence actual, CharSequence... values) Verifies that the givenCharSequence
does not contain any one of the given values, ignoring case considerations.<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) (package private) void
Arrays.assertDoesNotContainNull
(AssertionInfo info, Failures failures, Object array) void
Iterables.assertDoesNotContainNull
(AssertionInfo info, Iterable<?> actual) Asserts that the givenIterable
does not contain null elements.void
ObjectArrays.assertDoesNotContainNull
(AssertionInfo info, Object[] actual) Asserts that the given array does not contain null elements.void
Strings.assertDoesNotContainOnlyWhitespaces
(AssertionInfo info, CharSequence actual) Asserts that the givenCharSequence
isNull
, empty or contains at least one non-whitespace character.void
Strings.assertDoesNotContainPattern
(AssertionInfo info, CharSequence actual, CharSequence regex) Verifies that the givenCharSequence
does not contain the given regular expression.void
Strings.assertDoesNotContainPattern
(AssertionInfo info, CharSequence actual, Pattern pattern) Verifies that the givenCharSequence
does not contain the given regular expression.(package private) void
Arrays.assertDoesNotContainSequence
(AssertionInfo info, Failures failures, Object actual, Object sequence) void
Iterables.assertDoesNotContainSequence
(AssertionInfo info, Iterable<?> actual, Object[] sequence) Verifies that the given
does not contain the given sequence of objects in order.Iterable
void
ObjectArrays.assertDoesNotContainSequence
(AssertionInfo info, Object[] actual, Object[] sequence) Verifies that the given array does not contain the given sequence of objects in order.(package private) void
Arrays.assertDoesNotContainSubsequence
(AssertionInfo info, Failures failures, Object actual, Object subsequence) void
Iterables.assertDoesNotContainSubsequence
(AssertionInfo info, Iterable<?> actual, Object[] subsequence) Verifies that the given
does not contain the given subsequence of objects (possibly with other values between them).Iterable
void
ObjectArrays.assertDoesNotContainSubsequence
(AssertionInfo info, Object[] actual, Object[] subsequence) Verifies that the given array does not contain the given subsequence of objects (possibly with other values between them).<K,
V> void Maps.assertDoesNotContainValue
(AssertionInfo info, Map<K, V> actual, V value) void
Strings.assertDoesNotEndWith
(AssertionInfo info, CharSequence actual, CharSequence suffix) Verifies that the givenCharSequence
does not end with the given suffix.void
Strings.assertDoesNotEndWithIgnoringCase
(AssertionInfo info, CharSequence actual, CharSequence suffix) Verifies that the givenCharSequence
does not end with the given suffix, ignoring case considerations.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) (package private) void
Arrays.assertDoesNotHaveDuplicates
(AssertionInfo info, Failures failures, Object array) void
BooleanArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, boolean[] actual) Asserts that the given array does not have duplicate values.void
ByteArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, byte[] actual) Asserts that the given array does not have duplicate values.void
CharArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, char[] actual) Asserts that the given array does not have duplicate values.void
DoubleArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, double[] actual) Asserts that the given array does not have duplicate values.void
FloatArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, float[] actual) Asserts that the given array does not have duplicate values.void
IntArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, int[] actual) Asserts that the given array does not have duplicate values.void
Iterables.assertDoesNotHaveDuplicates
(AssertionInfo info, Iterable<?> actual) Asserts that the givenIterable
does not have duplicate values.void
LongArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, long[] actual) Asserts that the given array does not have duplicate values.void
ObjectArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, Object[] actual) Asserts that the given array does not have duplicate values.void
ShortArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, short[] actual) Asserts that the given array does not have duplicate values.void
Objects.assertDoesNotHaveSameClassAs
(AssertionInfo info, Object actual, Object other) Verifies that the actual value does not have the same class as the given object.<A> void
Objects.assertDoesNotHaveSameHashCodeAs
(AssertionInfo info, A actual, Object other) Asserts that the actual object does not the same hashCode as the given object.void
Objects.assertDoesNotHaveToString
(AssertionInfo info, Object actual, String otherToString) Verifies that the actual ToString value is not equal to the given String.void
Strings.assertDoesNotMatch
(AssertionInfo info, CharSequence actual, CharSequence regex) Verifies that the givenCharSequence
does not match the given regular expression.void
Strings.assertDoesNotMatch
(AssertionInfo info, CharSequence actual, Pattern pattern) Verifies that the givenCharSequence
does not match the given regular expression.void
Strings.assertDoesNotStartWith
(AssertionInfo info, CharSequence actual, CharSequence prefix) Verifies that the givenCharSequence
does not start with the given prefix.void
Strings.assertDoesNotStartWithIgnoringCase
(AssertionInfo info, CharSequence actual, CharSequence prefix) Verifies that the givenCharSequence
does not start with the given prefix, ignoring case considerations.<E> void
Iterables.assertDoNotHave
(AssertionInfo info, Iterable<? extends E> actual, Condition<? super E> condition) Assert that each element of givenIterable
not satisfies the given condition.<E> void
ObjectArrays.assertDoNotHave
(AssertionInfo info, E[] actual, Condition<? super E> condition) Assert that each element of given array not satisfies the given condition.private void
Iterables.assertElementOrder
(AssertionInfo info, Iterable<?> actual, Object[] values, List<Object> actualAsList) (package private) void
Arrays.assertEmpty
(AssertionInfo info, Failures failures, Object array) 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 givenIterable
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) Asserts that the givenCharSequence
is empty.(package private) void
Arrays.assertEndsWith
(AssertionInfo info, Failures failures, Object actual, Object sequence) (package private) void
Arrays.assertEndsWith
(AssertionInfo info, Failures failures, Object actual, Object first, Object[] rest) void
BooleanArrays.assertEndsWith
(AssertionInfo info, boolean[] actual, boolean[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
ByteArrays.assertEndsWith
(AssertionInfo info, byte[] actual, byte[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
ByteArrays.assertEndsWith
(AssertionInfo info, byte[] actual, int[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
CharArrays.assertEndsWith
(AssertionInfo info, char[] actual, char[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
DoubleArrays.assertEndsWith
(AssertionInfo info, double[] actual, double[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
FloatArrays.assertEndsWith
(AssertionInfo info, float[] actual, float[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
IntArrays.assertEndsWith
(AssertionInfo info, int[] actual, int[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
Iterables.assertEndsWith
(AssertionInfo info, Iterable<?> actual, Object[] sequence) Verifies that the givenIterable
ends with the given sequence of objects, without any other objects between them.void
Iterables.assertEndsWith
(AssertionInfo info, Iterable<?> actual, Object first, Object[] rest) Verifies that the givenIterable
ends with the given sequence of objects, without any other objects between them.void
LongArrays.assertEndsWith
(AssertionInfo info, long[] actual, long[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
ObjectArrays.assertEndsWith
(AssertionInfo info, Object[] actual, Object[] sequence) Verifies that the given array ends with the given sequence of objects, without any other objects between them.void
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) Verifies that the givenCharSequence
ends with the given suffix.void
Strings.assertEndsWithIgnoringCase
(AssertionInfo info, CharSequence actual, CharSequence suffix) Verifies that the givenCharSequence
ends with the given suffix, ignoring case considerations.void
Paths.assertEndsWithRaw
(AssertionInfo info, Path actual, Path end) void
Booleans.assertEqual
(AssertionInfo info, Boolean actual, boolean expected) Asserts that two booleans are equal.<T> void
Comparables.assertEqual
(AssertionInfo info, T actual, T expected) Asserts that two T instances are equal.void
Objects.assertEqual
(AssertionInfo info, Object actual, Object expected) Asserts that two objects are equal.<T> void
Comparables.assertEqualByComparison
(AssertionInfo info, Comparable<? super T> actual, T expected) Asserts that two
s are equal by invokingComparable
.Comparable.compareTo(Object)
Note that it does not rely on the customComparables.comparisonStrategy
if one has been set.void
Strings.assertEqualsIgnoringCase
(AssertionInfo info, CharSequence actual, CharSequence expected) Verifies that twoCharSequence
s are equal, ignoring case considerations.void
Strings.assertEqualsIgnoringWhitespace
(AssertionInfo info, CharSequence actual, CharSequence expected) Verifies that twoCharSequence
s are equal, ignoring any differences in whitespace.void
Strings.assertEqualsNormalizingPunctuationAndWhitespace
(AssertionInfo info, CharSequence actual, CharSequence expected) Verifies that twoCharSequence
s are equal, after the punctuation of both strings have been normalized.void
Strings.assertEqualsNormalizingWhitespace
(AssertionInfo info, CharSequence actual, CharSequence expected) Verifies that twoCharSequence
s are equal, after the whitespace of both strings has been normalized.void
Strings.assertEqualsToNormalizingUnicode
(AssertionInfo info, CharSequence actual, CharSequence expected) Verifies that twoCharSequence
s are equal, on their canonical form relying onNormalizer
.private void
Iterables.assertEquivalency
(AssertionInfo info, Iterable<?> actual, Object[] values, List<Object> actualAsList) 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) Futures.assertFailedWithin
(AssertionInfo info, Future<?> actual, long timeout, TimeUnit unit) Futures.assertFailedWithin
(AssertionInfo info, Future<?> actual, Duration timeout) <T> void
Comparables.assertGreaterThan
(AssertionInfo info, Comparable<? super T> actual, T other) private <T> void
Comparables.assertGreaterThan
(AssertionInfo info, Comparable<? super T> actual, T other, TriFunction<Comparable<? super T>, T, ComparisonStrategy, ErrorMessageFactory> errorMessageFactory) Asserts that the actual value is greater than the other one.<T> void
Comparables.assertGreaterThanOrEqualTo
(AssertionInfo info, Comparable<? super T> actual, T other) private <T> void
Comparables.assertGreaterThanOrEqualTo
(AssertionInfo info, Comparable<? super T> actual, T other, TriFunction<Comparable<? super T>, T, ComparisonStrategy, ErrorMessageFactory> errorMessageFactory) Asserts that the actual value is greater than or equal to the other one.<T> void
Conditions.assertHas
(AssertionInfo info, T actual, Condition<? super T> condition) Asserts that the actual value satisfies the given
.Condition
<T> void
Lists.assertHas
(AssertionInfo info, List<? extends T> actual, Condition<? super T> condition, Index index) Verifies that the givenList
satisfies the given
at the given index.Condition
<A> void
Objects.assertHasAllNullFieldsOrPropertiesExcept
(AssertionInfo info, A actual, String... propertiesOrFieldsToIgnore) Asserts that the given object has null fields except the given ones.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
InputStreams.assertHasBinaryContent
(AssertionInfo info, InputStream actual, byte[] expected) Asserts that the given InputStream has the given binary content.void
Paths.assertHasBinaryContent
(AssertionInfo info, Path actual, byte[] expected) void
Throwables.assertHasCause
(AssertionInfo info, Throwable actual) Asserts that the actualThrowable
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 actualThrowable
is exactly an instance of the given type.void
Throwables.assertHasCauseInstanceOf
(AssertionInfo info, Throwable actual, Class<? extends Throwable> type) Assert that the cause of actualThrowable
is an instance of the given type.void
Throwables.assertHasCauseReference
(AssertionInfo info, Throwable actual, Throwable expectedCause) Asserts that the actualThrowable
has a cause that refers to the expected one.void
Spliterators.assertHasCharacteristics
(AssertionInfo info, Spliterator<?> actual, int... characteristics) Asserts the given
has the given characteristics.Spliterator
void
Files.assertHasContent
(AssertionInfo info, File actual, String expected, Charset charset) Asserts that the given file has the given text content.void
InputStreams.assertHasContent
(AssertionInfo info, InputStream actual, String expected) Asserts that the given InputStream has the same content as the given String.void
Dates.assertHasDayOfMonth
(AssertionInfo info, Date actual, int dayOfMonth) Verifies that the actualDate
day of month is equal to the given day of month.void
Dates.assertHasDayOfWeek
(AssertionInfo info, Date actual, int dayOfWeek) Verifies that the actualDate
day of week is equal to the given day of week.void
Classes.assertHasDeclaredFields
(AssertionInfo info, Class<?> actual, String... fields) Verifies that the actualClass
has the declaredfields
.void
Classes.assertHasDeclaredMethods
(AssertionInfo info, Class<?> actual, String... methods) Verifies that the actualClass
has the declaredmethods
.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
InputStreams.assertHasDigest
(AssertionInfo info, InputStream actual, String algorithm, byte[] expected) void
InputStreams.assertHasDigest
(AssertionInfo info, InputStream actual, String algorithm, String expected) void
InputStreams.assertHasDigest
(AssertionInfo info, InputStream actual, MessageDigest digest, byte[] expected) void
InputStreams.assertHasDigest
(AssertionInfo info, InputStream 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 givenFile
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 actualDate
hour od day is equal to the given hour of day (24-hour clock).<K> void
Maps.assertHasKeySatisfying
(AssertionInfo info, Map<K, ?> actual, Condition<? super K> keyCondition) void
Strings.assertHasLineCount
(AssertionInfo info, CharSequence actual, int expectedLineCount) Asserts that the line count of the givenCharSequence
is equal to the expected one.void
Throwables.assertHasMessage
(AssertionInfo info, Throwable actual, String expectedMessage) Asserts that the given actualThrowable
message is equal to the given one.void
Throwables.assertHasMessageContaining
(AssertionInfo info, Throwable actual, String description) Asserts that the message of the actualThrowable
contains with the given description.void
Throwables.assertHasMessageContainingAll
(AssertionInfo info, Throwable actual, CharSequence... values) Asserts that the message of the actualThrowable
contains with the given values.void
Throwables.assertHasMessageEndingWith
(AssertionInfo info, Throwable actual, String description) Asserts that the message of the actualThrowable
ends with the given description.void
Throwables.assertHasMessageFindingMatch
(AssertionInfo info, Throwable actual, String regex) Asserts that a sequence of the message of the actualThrowable
matches with the given regular expression (seeMatcher.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 actualThrowable
matches with the given regular expression.void
Throwables.assertHasMessageNotContaining
(AssertionInfo info, Throwable actual, String content) Asserts that the message of the actualThrowable
does not contain the given content or isnull
.void
Throwables.assertHasMessageNotContainingAny
(AssertionInfo info, Throwable actual, CharSequence... values) Asserts that the message of the actualThrowable
does not contain any of the given values or isnull
.void
Throwables.assertHasMessageStartingWith
(AssertionInfo info, Throwable actual, String description) Asserts that the message of the actualThrowable
starts with the given description.void
Classes.assertHasMethods
(AssertionInfo info, Class<?> actual, String... methods) Verifies that the actualClass
has themethods
.void
Dates.assertHasMillisecond
(AssertionInfo info, Date actual, int millisecond) Verifies that the actualDate
millisecond is equal to the given millisecond.void
Dates.assertHasMinute
(AssertionInfo info, Date actual, int minute) Verifies that the actualDate
minute is equal to the given minute.void
Dates.assertHasMonth
(AssertionInfo info, Date actual, int month) Verifies that the actualDate
month is equal to the given month, month value starting at 1 (January=1, February=2, ...).void
Files.assertHasName
(AssertionInfo info, File actual, String expected) Asserts that the givenFile
has the given name.void
Iterators.assertHasNext
(AssertionInfo info, Iterator<?> actual) void
Throwables.assertHasNoCause
(AssertionInfo info, Throwable actual) Asserts that the actualThrowable
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) Assert that the given object has no null fields except the given ones.void
Uris.assertHasNoParameter
(AssertionInfo info, URI actual, String name) void
Uris.assertHasNoParameter
(AssertionInfo info, URI actual, String name, String unwantedValue) void
Urls.assertHasNoParameter
(AssertionInfo info, URL actual, String name) void
Urls.assertHasNoParameter
(AssertionInfo info, URL actual, String name, String unwantedValue) void
Uris.assertHasNoParameters
(AssertionInfo info, URI actual) void
Urls.assertHasNoParameters
(AssertionInfo info, URL actual) void
Files.assertHasNoParent
(AssertionInfo info, File actual) Asserts that the givenFile
does not have a parent.void
Paths.assertHasNoParent
(AssertionInfo info, Path actual) void
Paths.assertHasNoParentRaw
(AssertionInfo info, Path actual) void
Classes.assertHasNoSuperclass
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
has no superclass.void
Throwables.assertHasNoSuppressedExceptions
(AssertionInfo info, Throwable actual) void
Spliterators.assertHasOnlyCharacteristics
(AssertionInfo info, Spliterator<?> actual, int... characteristics) Asserts the given
has only the given characteristics and no else.Spliterator
void
Classes.assertHasOnlyDeclaredFields
(AssertionInfo info, Class<?> actual, String... expectedFields) Verifies that the actualClass
has the exactly thefields
and nothing more.<E> void
ObjectArrays.assertHasOnlyElementsOfType
(AssertionInfo info, E[] actual, Class<?> type) (package private) void
Arrays.assertHasOnlyElementsOfTypes
(AssertionInfo info, Failures failures, Object actual, Class<?>[] expectedTypes) <E> void
ObjectArrays.assertHasOnlyElementsOfTypes
(AssertionInfo info, E[] actual, Class<?>... types) <A> void
Objects.assertHasOnlyFields
(AssertionInfo info, A actual, String... names) <T> void
Iterables.assertHasOnlyOneElementSatisfying
(AssertionInfo info, Iterable<? extends T> actual, Consumer<? super T> consumer) void
Classes.assertHasOnlyPublicFields
(AssertionInfo info, Class<?> actual, String... expectedFields) Verifies that the actualClass
has only thefields
and nothing more.void
Classes.assertHasPackage
(AssertionInfo info, Class<?> actual, Package aPackage) Verifies that the actualClass
has the givenPackage
.void
Classes.assertHasPackage
(AssertionInfo info, Class<?> actual, String packageName) Verifies that the actualClass
has the givenpackageName
.void
Uris.assertHasParameter
(AssertionInfo info, URI actual, String name) void
Uris.assertHasParameter
(AssertionInfo info, URI actual, String expectedParameterName, String expectedParameterValue) void
Urls.assertHasParameter
(AssertionInfo info, URL actual, String name) void
Urls.assertHasParameter
(AssertionInfo info, URL actual, String expectedParameterName, String expectedParameterValue) void
Files.assertHasParent
(AssertionInfo info, File actual, File expected) Asserts that the givenFile
has the given parent.void
Paths.assertHasParent
(AssertionInfo info, Path actual, Path expected) void
Paths.assertHasParentRaw
(AssertionInfo info, Path actual, Path expected) void
Uris.assertHasPath
(AssertionInfo info, URI actual, String path) void
Urls.assertHasPath
(AssertionInfo info, URL actual, String path) void
Uris.assertHasPort
(AssertionInfo info, URI actual, Integer expected) void
Urls.assertHasPort
(AssertionInfo info, URL actual, int expected) void
Urls.assertHasProtocol
(AssertionInfo info, URL actual, String protocol) void
Classes.assertHasPublicFields
(AssertionInfo info, Class<?> actual, String... fields) Verifies that the actualClass
has thefields
.void
Classes.assertHasPublicMethods
(AssertionInfo info, Class<?> actual, String... methods) Verifies that the actualClass
has the publicmethods
.void
Uris.assertHasQuery
(AssertionInfo info, URI actual, String expected) void
Urls.assertHasQuery
(AssertionInfo info, URL actual, String expected) void
Throwables.assertHasRootCause
(AssertionInfo info, Throwable actual) Asserts that the actualThrowable
has a root cause.void
Throwables.assertHasRootCause
(AssertionInfo info, Throwable actual, Throwable expectedRootCause) Asserts that the actualThrowable
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 actualThrowable
is exactly an instance of the given type.void
Throwables.assertHasRootCauseInstanceOf
(AssertionInfo info, Throwable actual, Class<? extends Throwable> type) Assert that the root cause of actualThrowable
is an instance of the given type.void
Throwables.assertHasRootCauseMessage
(AssertionInfo info, Throwable actual, String expectedMessage) Asserts that the message of the root cause of the actualThrowable
is equal to the given one.void
Paths.assertHasSameBinaryContentAs
(AssertionInfo info, Path actual, Path expected) void
Objects.assertHasSameClassAs
(AssertionInfo info, Object actual, Object other) Verifies that the actual value has the same class as the given object.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) Asserts that the actual object has the same hashCode as the given object.(package private) void
Arrays.assertHasSameSizeAs
(AssertionInfo info, Object array, Iterable<?> other) void
Arrays.assertHasSameSizeAs
(AssertionInfo info, Object array, Object other) void
BooleanArrays.assertHasSameSizeAs
(AssertionInfo info, boolean[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
BooleanArrays.assertHasSameSizeAs
(AssertionInfo info, boolean[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
ByteArrays.assertHasSameSizeAs
(AssertionInfo info, byte[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
CharArrays.assertHasSameSizeAs
(AssertionInfo info, char[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
CharArrays.assertHasSameSizeAs
(AssertionInfo info, char[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
DoubleArrays.assertHasSameSizeAs
(AssertionInfo info, double[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
DoubleArrays.assertHasSameSizeAs
(AssertionInfo info, double[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
FloatArrays.assertHasSameSizeAs
(AssertionInfo info, float[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
FloatArrays.assertHasSameSizeAs
(AssertionInfo info, float[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
IntArrays.assertHasSameSizeAs
(AssertionInfo info, int[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
IntArrays.assertHasSameSizeAs
(AssertionInfo info, int[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
Iterables.assertHasSameSizeAs
(AssertionInfo info, Iterable<?> actual, Iterable<?> other) Assert that the actualIterable
has the same size as the otherIterable
.void
Iterables.assertHasSameSizeAs
(AssertionInfo info, Iterable<?> actual, Object other) Assert that the actualIterable
has the same size as the other array.void
LongArrays.assertHasSameSizeAs
(AssertionInfo info, long[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
LongArrays.assertHasSameSizeAs
(AssertionInfo info, long[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
Maps.assertHasSameSizeAs
(AssertionInfo info, Map<?, ?> map, Iterable<?> other) 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 otherIterable
.void
ObjectArrays.assertHasSameSizeAs
(AssertionInfo info, Object[] actual, Object other) Assert that the actual array has the same size as the other array.void
ShortArrays.assertHasSameSizeAs
(AssertionInfo info, short[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
ShortArrays.assertHasSameSizeAs
(AssertionInfo info, short[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
Strings.assertHasSameSizeAs
(AssertionInfo info, CharSequence actual, CharSequence other) void
Strings.assertHasSameSizeAs
(AssertionInfo info, CharSequence actual, Iterable<?> other) Asserts that the number of entries in the givenCharSequence
has the same size as the otherIterable
.void
Strings.assertHasSameSizeAs
(AssertionInfo info, CharSequence actual, Object array) Asserts that the number of entries in the givenCharSequence
has the same size as the other array.void
Paths.assertHasSameTextualContentAs
(AssertionInfo info, Path actual, Charset actualCharset, Path expected, Charset expectedCharset) void
Dates.assertHasSameTime
(AssertionInfo info, Date actual, Date expected) Verifies that the actualDate
has same time as the givenDate
.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 actualDate
second is equal to the given second.(package private) void
Arrays.assertHasSize
(AssertionInfo info, Object array, int expectedSize) void
BooleanArrays.assertHasSize
(AssertionInfo info, boolean[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
ByteArrays.assertHasSize
(AssertionInfo info, byte[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
CharArrays.assertHasSize
(AssertionInfo info, char[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
DoubleArrays.assertHasSize
(AssertionInfo info, double[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
FloatArrays.assertHasSize
(AssertionInfo info, float[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
IntArrays.assertHasSize
(AssertionInfo info, int[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
Iterables.assertHasSize
(AssertionInfo info, Iterable<?> actual, int expectedSize) Asserts that the number of elements in the givenIterable
is equal to the expected one.void
LongArrays.assertHasSize
(AssertionInfo info, long[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
Maps.assertHasSize
(AssertionInfo info, Map<?, ?> actual, int expectedSize) 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) Asserts that the size of the givenCharSequence
is equal to the expected one.(package private) void
Arrays.assertHasSizeBetween
(AssertionInfo info, Object array, int lowerBoundary, int higherBoundary) 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 givenIterable
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) Asserts that the size of the givenCharSequence
is between the given lower and higher boundary (inclusive).(package private) void
Arrays.assertHasSizeGreaterThan
(AssertionInfo info, Object array, int boundary) 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 givenIterable
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) Asserts that the size of the givenCharSequence
is greater than the expected size(package private) void
Arrays.assertHasSizeGreaterThanOrEqualTo
(AssertionInfo info, Object array, int boundary) 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 givenIterable
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) Asserts that the size of the givenCharSequence
is greater than or equal to the expected sizevoid
Files.assertHasSizeInBytes
(AssertionInfo info, File actual, long expectedSizeInBytes) Asserts that the given file has the given size in bytes.(package private) void
Arrays.assertHasSizeLessThan
(AssertionInfo info, Object array, int boundary) 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 givenIterable
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) Asserts that the size of the givenCharSequence
is less than the expected size(package private) void
Arrays.assertHasSizeLessThanOrEqualTo
(AssertionInfo info, Object array, int expectedSize) 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 givenIterable
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) Asserts that the size of the givenCharSequence
is less than or equal to the expected sizevoid
Throwables.assertHasStackTraceContaining
(AssertionInfo info, Throwable actual, String description) Asserts that the stack trace of the actualThrowable
contains with the given description.void
Classes.assertHasSuperclass
(AssertionInfo info, Class<?> actual, Class<?> superclass) Verifies that the actualClass
has the given class as directsuperclass
.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 actualDate
time is equal to the given timestamp.void
Objects.assertHasToString
(AssertionInfo info, Object actual, String expectedToString) Verifies that the actual ToString value is equal to the given String.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 actualDate
year is equal to the given year.<E> void
Arrays.assertHave
(AssertionInfo info, Failures failures, Conditions conditions, Object array, Condition<E> condition) <E> void
Iterables.assertHave
(AssertionInfo info, Iterable<? extends E> actual, Condition<? super E> condition) Assert that each element of givenIterable
satisfies the given condition.<E> void
ObjectArrays.assertHave
(AssertionInfo info, E[] actual, Condition<? super E> condition) Assert that each element of given array satisfies the given condition.<E> void
Arrays.assertHaveAtLeast
(AssertionInfo info, Failures failures, Conditions conditions, Object array, int times, Condition<E> condition) <E> void
Iterables.assertHaveAtLeast
(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition) An alias method ofIterables.assertAreAtLeast(AssertionInfo, Iterable, int, Condition)
to provide a richer fluent api (same logic, only error message differs).<E> void
ObjectArrays.assertHaveAtLeast
(AssertionInfo info, E[] actual, int times, Condition<? super E> condition) An alias method ofObjectArrays.assertAreAtLeast(AssertionInfo, Object[], int, Condition)
to provide a richer fluent api (same logic, only error message differs).<E> void
Arrays.assertHaveAtMost
(AssertionInfo info, Failures failures, Conditions conditions, Object array, int times, Condition<E> condition) <E> void
Iterables.assertHaveAtMost
(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition) An alias method ofIterables.assertAreAtMost(AssertionInfo, Iterable, int, Condition)
to provide a richer fluent api (same logic, only error message differs).<E> void
ObjectArrays.assertHaveAtMost
(AssertionInfo info, E[] actual, int times, Condition<? super E> condition) An alias method ofObjectArrays.assertAreAtMost(AssertionInfo, Object[], int, Condition)
to provide a richer fluent api (same logic, only error message differs).<E> void
Arrays.assertHaveExactly
(AssertionInfo info, Failures failures, Conditions conditions, Object array, int times, Condition<E> condition) <E> void
Iterables.assertHaveExactly
(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition) An alias method ofIterables.assertAreExactly(AssertionInfo, Iterable, int, Condition)
to provide a richer fluent api (same logic, only error message differs).<E> void
ObjectArrays.assertHaveExactly
(AssertionInfo info, E[] actual, int times, Condition<? super E> condition) An alias method ofObjectArrays.assertAreExactly(AssertionInfo, Object[], int, Condition)
to provide a richer fluent api (same logic, only error message differs).<E> void
Arrays.assertHaveNot
(AssertionInfo info, Failures failures, Conditions conditions, Object array, Condition<E> condition) 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 givenList
satisfies the given
at the given index.Condition
void
Files.assertIsAbsolute
(AssertionInfo info, File actual) Asserts that the given file is an absolute path.void
Paths.assertIsAbsolute
(AssertionInfo info, Path actual) void
Classes.assertIsAbstract
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is abstract.<T> void
Comparables.assertIsAfter
(AssertionInfo info, Comparable<? super T> actual, T other) void
Dates.assertIsAfter
(AssertionInfo info, Date actual, Date other) Verifies that the actualDate
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 actualDate
is after or equal to the given one.void
Dates.assertIsAfterYear
(AssertionInfo info, Date actual, int year) Verifies that the actualDate
is strictly after the given year.void
Classes.assertIsAnnotation
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is an annotation.static void
Arrays.assertIsArray
(AssertionInfo info, Object array) void
Classes.assertIsAssignableFrom
(AssertionInfo info, Class<?> actual, Class<?>... others) Verifies that the actualClass
is assignable from all theothers
classes.void
Strings.assertIsBase64
(AssertionInfo info, String actual) Verifies that actual is a valid Base64 encoded string.<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 actualDate
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 actualDate
is before or equal to the given one.void
Dates.assertIsBeforeYear
(AssertionInfo info, Date actual, int year) Verifies that the actualDate
is strictly before the given year.<T> 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 actualDate
is in start:end period.
start date belongs to the period if inclusiveStart is true.
end date belongs to the period if inclusiveEnd is true.void
Numbers.assertIsBetween
(AssertionInfo info, NUMBER actual, NUMBER start, NUMBER end) Asserts that the actual value is in [start, end] range (start included, end included).void
Futures.assertIsCancelled
(AssertionInfo info, Future<?> actual) Verifies that theFuture
is cancelled.void
Paths.assertIsCanonical
(AssertionInfo info, Path actual) void
Dates.assertIsCloseTo
(AssertionInfo info, Date actual, Date other, long deltaInMilliseconds) Verifies that the actualDate
is close to the other date by less than delta, if difference is equals to delta it is ok.
Note that delta expressed in milliseconds.
Use handy TimeUnit to convert a duration in milliseconds, for example you can express a delta of 5 seconds withTimeUnit.SECONDS.toMillis(5)
.void
Numbers.assertIsCloseTo
(AssertionInfo info, NUMBER actual, NUMBER expected, Offset<NUMBER> offset) Asserts that the actual value is close to the 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) private void
Files.assertIsDirectoryContaining
(AssertionInfo info, File actual, FileFilter filter, String filterPresentation) 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) private void
Paths.assertIsDirectoryContaining
(AssertionInfo info, Path actual, DirectoryStream.Filter<Path> filter, String filterPresentation) void
Paths.assertIsDirectoryContaining
(AssertionInfo info, Path actual, Predicate<Path> filter) private void
Files.assertIsDirectoryNotContaining
(AssertionInfo info, File actual, FileFilter filter, String filterPresentation) 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) private void
Paths.assertIsDirectoryNotContaining
(AssertionInfo info, Path actual, DirectoryStream.Filter<Path> filter, String filterPresentation) 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) private void
Files.assertIsDirectoryRecursivelyContaining
(AssertionInfo info, File actual, Predicate<File> filter, String filterPresentation) void
Paths.assertIsDirectoryRecursivelyContaining
(AssertionInfo info, Path actual, String syntaxAndPattern) void
Paths.assertIsDirectoryRecursivelyContaining
(AssertionInfo info, Path actual, Predicate<Path> filter) private void
Paths.assertIsDirectoryRecursivelyContaining
(AssertionInfo info, Path actual, Predicate<Path> filter, String filterPresentation) void
Futures.assertIsDone
(AssertionInfo info, Future<?> actual) Verifies that theFuture
is done.void
InputStreams.assertIsEmpty
(AssertionInfo info, InputStream actual) Asserts that the given InputStreams is empty.void
Files.assertIsEmptyDirectory
(AssertionInfo info, File actual) void
Paths.assertIsEmptyDirectory
(AssertionInfo info, Path actual) void
Files.assertIsEmptyFile
(AssertionInfo info, File actual) Asserts that the givenFile
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) Assert that the given object is "deeply" equals to other by comparing all fields recursively.<A> void
Objects.assertIsEqualToComparingOnlyGivenFields
(AssertionInfo info, A actual, A other, Map<String, Comparator<?>> comparatorByPropertyOrField, TypeComparators comparatorByType, String... fields) Assert that the given object is lenient equals to other object by comparing given fields value only.<A> void
Objects.assertIsEqualToIgnoringGivenFields
(AssertionInfo info, A actual, A other, Map<String, Comparator<?>> comparatorByPropertyOrField, TypeComparators comparatorByType, String... fields) Assert that the given object is lenient equals to the other by comparing all fields (including inherited fields) unless given ignored ones.void
Strings.assertIsEqualToIgnoringNewLines
(AssertionInfo info, CharSequence actual, CharSequence expected) Verifies that actual is equal to expected ignoring new lines<A> void
Objects.assertIsEqualToIgnoringNullFields
(AssertionInfo info, A actual, A other, Map<String, Comparator<?>> comparatorByPropertyOrField, TypeComparators comparatorByType) Assert that the given object is lenient equals by ignoring null fields value on other object (including inherited fields).void
Strings.assertIsEqualToNormalizingNewlines
(AssertionInfo info, CharSequence actual, CharSequence expected) Verifies that twoCharSequence
s are equal, normalizing newlines.void
Urls.assertIsEqualToWithSortedQueryParameters
(AssertionInfo info, URL actual, URL expected) void
Dates.assertIsEqualWithPrecision
(AssertionInfo info, Date actual, Date other, TimeUnit precision) Verifies that the actualDate
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) Verifies that the actual value is exactly an instance of given 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
Classes.assertIsFinal
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is final.void
RealNumbers.assertIsFinite
(AssertionInfo info, NUMBER actual) void
Objects.assertIsIn
(AssertionInfo info, Object actual, Iterable<?> values) Asserts that the given object is present in the given collection.void
Objects.assertIsIn
(AssertionInfo info, Object actual, Object[] values) Asserts that the given object is present in the given array.void
RealNumbers.assertIsInfinite
(AssertionInfo info, NUMBER actual) void
Dates.assertIsInSameDayAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are chronologically in the same day of month (and thus in the same month and year).void
Dates.assertIsInSameHourAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are in the same hour (and thus in the same day of month, month and year).void
Dates.assertIsInSameHourWindowAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are chronologically in the same hour, day of month, month and year.void
Dates.assertIsInSameMinuteAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are in the same minute, hour, day of month, month and year.void
Dates.assertIsInSameMinuteWindowAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are chronologically in the same minute.void
Dates.assertIsInSameMonthAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are chronologically in the same month (and thus in the same year).void
Dates.assertIsInSameSecondAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are in the same second, minute, hour, day of month, month and year.void
Dates.assertIsInSameSecondWindowAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are chronologically in the same second.void
Dates.assertIsInSameYearAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are in the same year.void
Objects.assertIsInstanceOf
(AssertionInfo info, Object actual, Class<?> type) Verifies that the given object is an instance of the given type.void
Objects.assertIsInstanceOfAny
(AssertionInfo info, Object actual, Class<?>[] types) Verifies that the given object is an instance of any of the given types.void
Classes.assertIsInterface
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is an interface.void
Dates.assertIsInTheFuture
(AssertionInfo info, Date actual) Verifies that the actualDate
is strictly in the future.void
Dates.assertIsInThePast
(AssertionInfo info, Date actual) Verifies that the actualDate
is strictly in the past.void
RealNumbers.assertIsNaN
(AssertionInfo info, NUMBER actual) Verifies that the actual value is equal toNaN
.
It does not rely on the custom comparisonStrategy (if one is set).void
Numbers.assertIsNegative
(AssertionInfo info, NUMBER actual) Asserts that the actual value is negative.void
Paths.assertIsNormalized
(AssertionInfo info, Path actual) <T> void
Conditions.assertIsNot
(AssertionInfo info, T actual, Condition<? super T> condition) Asserts that the actual value does not satisfy the given
.Condition
void
Classes.assertIsNotAnnotation
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is not an annotation.void
Dates.assertIsNotBetween
(AssertionInfo info, Date actual, Date start, Date end, boolean inclusiveStart, boolean inclusiveEnd) Verifies that the actualDate
is not in start:end period..
start date belongs to the period if inclusiveStart is true.
end date belongs to the period if inclusiveEnd is true.void
Futures.assertIsNotCancelled
(AssertionInfo info, Future<?> actual) Verifies that theFuture
is not cancelled.void
Numbers.assertIsNotCloseTo
(AssertionInfo info, NUMBER actual, NUMBER expected, Offset<NUMBER> offset) Asserts that the actual value is not close to the 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 theFuture
is not done.void
InputStreams.assertIsNotEmpty
(AssertionInfo info, InputStream actual) Asserts that the given InputStreams is not empty.void
Files.assertIsNotEmptyDirectory
(AssertionInfo info, File actual) void
Paths.assertIsNotEmptyDirectory
(AssertionInfo info, Path actual) void
Files.assertIsNotEmptyFile
(AssertionInfo info, File actual) Asserts that the givenFile
is not empty (i.e.void
Paths.assertIsNotEmptyFile
(AssertionInfo info, Path actual) void
Objects.assertIsNotExactlyInstanceOf
(AssertionInfo info, Object actual, Class<?> type) Verifies that the actual value is not exactly an instance of given type.void
Classes.assertIsNotFinal
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is not final.void
RealNumbers.assertIsNotFinite
(AssertionInfo info, NUMBER actual) void
Objects.assertIsNotIn
(AssertionInfo info, Object actual, Iterable<?> values) Asserts that the given object is not present in the given collection.void
Objects.assertIsNotIn
(AssertionInfo info, Object actual, Object[] values) Asserts that the given object is not present in the given array.void
RealNumbers.assertIsNotInfinite
(AssertionInfo info, NUMBER actual) void
Objects.assertIsNotInstanceOf
(AssertionInfo info, Object actual, Class<?> type) Verifies that the given object is not an instance of the given type.void
Objects.assertIsNotInstanceOfAny
(AssertionInfo info, Object actual, Class<?>[] types) Verifies that the given object is not an instance of any of the given types.void
Classes.assertIsNotInterface
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is not an interface.void
RealNumbers.assertIsNotNaN
(AssertionInfo info, NUMBER actual) Verifies that the actual value is not equal toNaN
.void
Numbers.assertIsNotNegative
(AssertionInfo info, NUMBER actual) Asserts that the actual value is not negative.void
Objects.assertIsNotOfAnyClassIn
(AssertionInfo info, Object actual, Class<?>[] types) Verifies that the actual value type is not in given types.void
Numbers.assertIsNotPositive
(AssertionInfo info, NUMBER actual) Asserts that the actual value is not positive.void
Classes.assertIsNotStatic
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is not static.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) Verifies that the actual value type is in given types.void
Numbers.assertIsOne
(AssertionInfo info, NUMBER actual) Asserts that the actual value is equal to one.
It does not rely on the custom comparisonStrategy (if one is set).void
Classes.assertIsPackagePrivate
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is package-private.void
Numbers.assertIsPositive
(AssertionInfo info, NUMBER actual) Asserts that the actual value is positive.void
Classes.assertIsProtected
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is protected.void
Classes.assertIsPublic
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is public.void
Paths.assertIsReadable
(AssertionInfo info, Path actual) void
Paths.assertIsRegularFile
(AssertionInfo info, Path actual) void
Files.assertIsRelative
(AssertionInfo info, File actual) Asserts that the given file is a relative path.void
Paths.assertIsRelative
(AssertionInfo info, Path actual) (package private) void
Arrays.assertIsSorted
(AssertionInfo info, Failures failures, Object array) void
BooleanArrays.assertIsSorted
(AssertionInfo info, boolean[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.void
ByteArrays.assertIsSorted
(AssertionInfo info, byte[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.void
CharArrays.assertIsSorted
(AssertionInfo info, char[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.void
DoubleArrays.assertIsSorted
(AssertionInfo info, double[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.void
FloatArrays.assertIsSorted
(AssertionInfo info, float[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.void
IntArrays.assertIsSorted
(AssertionInfo info, int[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.void
Lists.assertIsSorted
(AssertionInfo info, List<?> actual) Verifies that the actual list is sorted in ascending order according to the natural ordering of its elements.void
LongArrays.assertIsSorted
(AssertionInfo info, long[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.void
ObjectArrays.assertIsSorted
(AssertionInfo info, Object[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.void
ShortArrays.assertIsSorted
(AssertionInfo info, short[] actual) Concrete implementation ofArraySortedAssert.isSorted()
.(package private) static <T> void
Arrays.assertIsSortedAccordingToComparator
(AssertionInfo info, Failures failures, Object array, Comparator<T> comparator) void
BooleanArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, boolean[] actual, Comparator<? super Boolean> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.void
ByteArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, byte[] actual, Comparator<? super Byte> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.void
CharArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, char[] actual, Comparator<? super Character> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.void
DoubleArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, double[] actual, Comparator<? super Double> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.void
FloatArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, float[] actual, Comparator<? super Float> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.void
IntArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, int[] actual, Comparator<? super Integer> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.void
Lists.assertIsSortedAccordingToComparator
(AssertionInfo info, List<?> actual, Comparator<?> comparator) Verifies that the actual list is sorted according to the given comparator.
Empty lists are considered sorted whatever the comparator is.
One element lists are considered sorted if the element is compatible with comparator.void
LongArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, long[] actual, Comparator<? super Long> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.<E> void
ObjectArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, E[] actual, Comparator<? super E> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.void
ShortArrays.assertIsSortedAccordingToComparator
(AssertionInfo info, short[] actual, Comparator<? super Short> comparator) Concrete implementation ofArraySortedAssert.isSortedAccordingTo(Comparator)
.void
Classes.assertIsStatic
(AssertionInfo info, Class<?> actual) Verifies that the actualClass
is static.void
Numbers.assertIsStrictlyBetween
(AssertionInfo info, NUMBER actual, NUMBER start, NUMBER end) Asserts that the actual value is in ]start, end[ range (start excluded, end excluded).void
Arrays.assertIsSubsetOf
(AssertionInfo info, Failures failures, Object actual, Iterable<?> values) void
Iterables.assertIsSubsetOf
(AssertionInfo info, Iterable<?> actual, Iterable<?> values) Verifies that the actualIterable
is a subset of valuesIterable
.void
ObjectArrays.assertIsSubsetOf
(AssertionInfo info, Object actual, Iterable<?> values) void
Strings.assertIsSubstringOf
(AssertionInfo info, CharSequence actual, CharSequence sequence) void
Paths.assertIsSymbolicLink
(AssertionInfo info, Path actual) void
Dates.assertIsToday
(AssertionInfo info, Date actual) Verifies that the actualDate
is today, by comparing only year, month and day of actual to today (ie.void
Paths.assertIsWritable
(AssertionInfo info, Path actual) void
Numbers.assertIsZero
(AssertionInfo info, NUMBER actual) Asserts that the actual value is equal to zero.
It does not rely on the custom comparisonStrategy (if one is set).private void
Iterables.assertIterableContainsGivenValues
(Class<? extends Iterable> clazz, Iterable<?> actual, Object[] values, AssertionInfo info) void
Strings.assertJavaBlank
(AssertionInfo info, CharSequence actual) Asserts that the givenCharSequence
consists of one or more whitespace characters according toCharacter.isWhitespace(char)
.<T> void
Comparables.assertLessThan
(AssertionInfo info, Comparable<? super T> actual, T other) Asserts that the actual value is less than the other one.private <T> void
Comparables.assertLessThan
(AssertionInfo info, Comparable<? super T> actual, T other, TriFunction<Comparable<? super T>, T, ComparisonStrategy, ErrorMessageFactory> errorMessageFactory) Asserts that the actual value is less than the other one and throws an error with the given message factory.<T> void
Comparables.assertLessThanOrEqualTo
(AssertionInfo info, Comparable<? super T> actual, T other) private <T> void
Comparables.assertLessThanOrEqualTo
(AssertionInfo info, Comparable<? super T> actual, T other, TriFunction<Comparable<? super T>, T, ComparisonStrategy, ErrorMessageFactory> errorMessageFactory) Asserts that the actual value is less than or equal to the other one.void
Characters.assertLowerCase
(AssertionInfo info, Character actual) Asserts that the actual value is a lowercase character.void
Strings.assertLowerCase
(AssertionInfo info, CharSequence actual) void
Strings.assertMatches
(AssertionInfo info, CharSequence actual, CharSequence regex) Verifies that the givenCharSequence
matches the given regular expression.void
Strings.assertMatches
(AssertionInfo info, CharSequence actual, Matcher matcher) Verifies that the givenCharSequence
matches the given regular expression.void
Strings.assertMatches
(AssertionInfo info, CharSequence actual, Pattern pattern) Verifies that the givenCharSequence
matches the given regular expression.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
Strings.assertNotBlank
(AssertionInfo info, CharSequence actual) Asserts that the givenCharSequence
contains at least one non-whitespace character.(package private) void
Arrays.assertNotEmpty
(AssertionInfo info, Failures failures, Object array) 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 givenIterable
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) Asserts that the givenCharSequence
is not empty.void
Booleans.assertNotEqual
(AssertionInfo info, Boolean actual, boolean other) Asserts that two longs are not equal.<T> void
Comparables.assertNotEqual
(AssertionInfo info, T actual, T other) Asserts that two T instances are not equal.void
Objects.assertNotEqual
(AssertionInfo info, Object actual, Object other) Asserts that two objects are not equal.<T> void
Comparables.assertNotEqualByComparison
(AssertionInfo info, Comparable<? super T> actual, T other) Asserts that two
s are not equal by invokingComparable
.Comparable.compareTo(Object)
Note that it does not rely on the customComparables.comparisonStrategy
if one has been set.void
Strings.assertNotEqualsIgnoringCase
(AssertionInfo info, CharSequence actual, CharSequence expected) Verifies that twoCharSequence
s are not equal, ignoring case considerations.void
Strings.assertNotEqualsIgnoringWhitespace
(AssertionInfo info, CharSequence actual, CharSequence expected) Verifies that twoCharSequence
s are not equal, ignoring any differences in whitespace.void
Strings.assertNotEqualsNormalizingWhitespace
(AssertionInfo info, CharSequence actual, CharSequence expected) Verifies that twoCharSequence
s are not equal, after the whitespace of both strings has been normalized.void
Strings.assertNotJavaBlank
(AssertionInfo info, CharSequence actual) Asserts that the givenCharSequence
isNull
, empty or contains at least one non-whitespace character according toCharacter.isWhitespace(char)
.(package private) static void
Arrays.assertNotNull
(AssertionInfo info, Object array) private static void
Booleans.assertNotNull
(AssertionInfo info, Boolean actual) private static void
Classes.assertNotNull
(AssertionInfo info, Class<?> actual) protected static <T> void
Comparables.assertNotNull
(AssertionInfo info, T actual) private void
Dates.assertNotNull
(AssertionInfo info, Date actual) private static void
Files.assertNotNull
(AssertionInfo info, File actual) private void
Futures.assertNotNull
(AssertionInfo info, Future<?> actual) private static void
InputStreams.assertNotNull
(AssertionInfo info, InputStream stream) (package private) void
Iterables.assertNotNull
(AssertionInfo info, Iterable<?> actual) private void
Lists.assertNotNull
(AssertionInfo info, List<?> actual) private void
Maps.assertNotNull
(AssertionInfo info, Map<?, ?> actual) void
Objects.assertNotNull
(AssertionInfo info, Object actual) Asserts that the given object is notnull
.void
Objects.assertNotNull
(AssertionInfo info, Object actual, String label) Asserts that the given object is notnull
.private static void
Paths.assertNotNull
(AssertionInfo info, Path actual) private void
Strings.assertNotNull
(AssertionInfo info, CharSequence actual) private static void
Throwables.assertNotNull
(AssertionInfo info, Throwable actual) void
Objects.assertNotSame
(AssertionInfo info, Object actual, Object other) Asserts that two objects do not refer to the same object.void
Objects.assertNull
(AssertionInfo info, Object actual) Asserts that the given object isnull
.(package private) void
Arrays.assertNullOrEmpty
(AssertionInfo info, Failures failures, Object array) void
Arrays2D.assertNullOrEmpty
(AssertionInfo info, Failures failures, Object array) void
Boolean2DArrays.assertNullOrEmpty
(AssertionInfo info, boolean[][] actual) Asserts that the given array isnull
or empty.void
BooleanArrays.assertNullOrEmpty
(AssertionInfo info, boolean[] actual) Asserts that the given array isnull
or empty.void
Byte2DArrays.assertNullOrEmpty
(AssertionInfo info, byte[][] actual) Asserts that the given array isnull
or empty.void
ByteArrays.assertNullOrEmpty
(AssertionInfo info, byte[] actual) Asserts that the given array isnull
or empty.void
Char2DArrays.assertNullOrEmpty
(AssertionInfo info, char[][] actual) Asserts that the given array isnull
or empty.void
CharArrays.assertNullOrEmpty
(AssertionInfo info, char[] actual) Asserts that the given array isnull
or empty.void
Double2DArrays.assertNullOrEmpty
(AssertionInfo info, double[][] actual) Asserts that the given array isnull
or empty.void
DoubleArrays.assertNullOrEmpty
(AssertionInfo info, double[] actual) Asserts that the given array isnull
or empty.void
Float2DArrays.assertNullOrEmpty
(AssertionInfo info, float[][] actual) Asserts that the given array isnull
or empty.void
FloatArrays.assertNullOrEmpty
(AssertionInfo info, float[] actual) Asserts that the given array isnull
or empty.void
Int2DArrays.assertNullOrEmpty
(AssertionInfo info, int[][] actual) Asserts that the given array isnull
or empty.void
IntArrays.assertNullOrEmpty
(AssertionInfo info, int[] actual) Asserts that the given array isnull
or empty.void
Iterables.assertNullOrEmpty
(AssertionInfo info, Iterable<?> actual) Asserts that the given
isIterable
null
or empty.void
Long2DArrays.assertNullOrEmpty
(AssertionInfo info, long[][] actual) Asserts that the given array isnull
or empty.void
LongArrays.assertNullOrEmpty
(AssertionInfo info, long[] actual) Asserts that the given array isnull
or empty.void
Maps.assertNullOrEmpty
(AssertionInfo info, Map<?, ?> actual) void
Object2DArrays.assertNullOrEmpty
(AssertionInfo info, ELEMENT[][] actual) Asserts that the given array isnull
or empty.void
ObjectArrays.assertNullOrEmpty
(AssertionInfo info, Object[] actual) Asserts that the given array isnull
or empty.void
Short2DArrays.assertNullOrEmpty
(AssertionInfo info, short[][] actual) Asserts that the given array isnull
or empty.void
ShortArrays.assertNullOrEmpty
(AssertionInfo info, short[] actual) Asserts that the given array isnull
or empty.void
Strings.assertNullOrEmpty
(AssertionInfo info, CharSequence actual) Asserts that the givenCharSequence
isnull
or empty.void
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) Asserts that two objects refer to the same object.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.void
InputStreams.assertSameContentAs
(AssertionInfo info, InputStream actual, InputStream expected) Asserts that the given InputStreams 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) private void
Arrays2D.assertSecondDimension
(AssertionInfo info, Failures failures, Object actual, int expectedSize, int rowIndex) (package private) void
Arrays.assertStartsWith
(AssertionInfo info, Failures failures, Object actual, Object sequence) void
BooleanArrays.assertStartsWith
(AssertionInfo info, boolean[] actual, boolean[] sequence) Verifies that the given array starts with the given sequence of values, without any other values between them.void
ByteArrays.assertStartsWith
(AssertionInfo info, byte[] actual, byte[] sequence) Verifies that the given array starts with the given sequence of values, without any other values between them.void
ByteArrays.assertStartsWith
(AssertionInfo info, byte[] actual, int[] sequence) Verifies that the given array starts with the given sequence of values, without any other values between them.void
CharArrays.assertStartsWith
(AssertionInfo info, char[] actual, char[] sequence) Verifies that the given array starts with the given sequence of values, without any other values between them.void
DoubleArrays.assertStartsWith
(AssertionInfo info, double[] actual, double[] sequence) Verifies that the given array starts with the given sequence of values, without any other values between them.void
FloatArrays.assertStartsWith
(AssertionInfo info, float[] actual, float[] sequence) Verifies that the given array starts with the given sequence of values, without any other values between them.void
IntArrays.assertStartsWith
(AssertionInfo info, int[] actual, int[] sequence) Verifies that the given array starts with the given sequence of values, without any other values between them.void
Iterables.assertStartsWith
(AssertionInfo info, Iterable<?> actual, Object[] sequence) Verifies that the givenIterable
starts with the given sequence of objects, without any other objects between them.void
LongArrays.assertStartsWith
(AssertionInfo info, long[] actual, long[] sequence) Verifies that the given array starts with the given sequence of values, without any other values between them.void
ObjectArrays.assertStartsWith
(AssertionInfo info, Object[] actual, Object[] sequence) Verifies that the given array starts with the given sequence of objects, without any other objects between them.void
Paths.assertStartsWith
(AssertionInfo info, Path actual, Path 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) Verifies that the givenCharSequence
starts with the given prefix.void
Strings.assertStartsWithIgnoringCase
(AssertionInfo info, CharSequence actual, CharSequence prefix) Verifies that the givenCharSequence
starts with the given prefix, ignoring case considerations.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) private static void
Arrays.assertThatArrayComponentTypeIsSortable
(AssertionInfo info, Failures failures, Object array) void
Characters.assertUpperCase
(AssertionInfo info, Character actual) Asserts that the actual value is a uppercase character.void
Strings.assertUpperCase
(AssertionInfo info, CharSequence actual) void
Strings.assertVisible
(AssertionInfo info, CharSequence actual) void
Strings.assertXmlEqualsTo
(AssertionInfo info, CharSequence actualXml, CharSequence expectedXml) <ACTUAL_ELEMENT,
OTHER_ELEMENT>
voidIterables.assertZipSatisfy
(AssertionInfo info, Iterable<? extends ACTUAL_ELEMENT> actual, Iterable<OTHER_ELEMENT> other, BiConsumer<? super ACTUAL_ELEMENT, OTHER_ELEMENT> zipRequirements) private static void
Arrays2D.checkArraySizes
(Object actual, Failures failures, int sizeOfActual, int sizeOfOther, AssertionInfo info, int rowIndex) static void
CommonValidations.checkLineCounts
(Object actual, int lineCountOfActual, int lineCountOfOther, AssertionInfo info) private void
Iterables.checkNotNullIterables
(AssertionInfo info, Iterable<?> actual, Object[] sequence) private static void
Arrays.checkNulls
(AssertionInfo info, Object actual, Object sequence) (package private) static void
CommonValidations.checkSameSizes
(AssertionInfo info, Object actual, Object other, int sizeOfActual, int sizeOfOther) 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) private static boolean
Arrays.commonChecks
(AssertionInfo info, Object actual, Object sequence) private boolean
Iterables.commonCheckThatIterableAssertionSucceeds
(AssertionInfo info, Iterable<?> actual, Object[] sequence) private <T> boolean
Lists.conditionIsMetAtIndex
(AssertionInfo info, List<T> actual, Condition<? super T> condition, Index index) Files.directoryContent
(AssertionInfo info, File actual) Paths.directoryContent
(AssertionInfo info, Path actual) private void
Classes.doAssertHasMethods
(AssertionInfo info, Class<?> actual, Set<Method> actualMethods, boolean declared, String... expectedMethods) private void
Strings.doCommonCheckForCharSequence
(AssertionInfo info, CharSequence actual, CharSequence[] sequence) private static void
Throwables.doCommonCheckForMessages
(AssertionInfo info, Throwable actual, CharSequence[] values) private <K,
V> void Maps.doCommonContainsCheck
(AssertionInfo info, Map<K, V> actual, Map.Entry<? extends K, ? extends V>[] entries) private <K,
V> void Maps.failIfAnyEntryNotFoundInActualMap
(AssertionInfo info, Map<K, V> actual, Map.Entry<? extends K, ? extends V>[] entries) private <K,
V> void Maps.failIfEntriesIsEmptySinceActualIsNotEmpty
(AssertionInfo info, Map<K, V> actual, Map.Entry<? extends K, ? extends V>[] entries) Failures.failure
(AssertionInfo info, AssertionErrorFactory factory) Creates a
following this pattern: creates aAssertionError
usingAssertionError
as the error message if such value is notoverridingErrorMessage()
null
, or uses the given
to create anAssertionErrorFactory
, prepending the value ofAssertionError
to the error messagedescription()
Failures.failure
(AssertionInfo info, ErrorMessageFactory messageFactory) Creates a
following this pattern: creates aAssertionError
usingAssertionError
as the error message if such value is notoverridingErrorMessage()
null
, or uses the given
to create the detail message of theErrorMessageFactory
, prepending the value ofAssertionError
to the error messagedescription()
Failures.failure
(AssertionInfo info, ErrorMessageFactory messageFactory, Object actual, Object expected) Failures.failureIfErrorMessageIsOverridden
(AssertionInfo info) private static FileFilter
Files.fileFilter
(AssertionInfo info, File actual, String syntaxAndPattern) Files.filterDirectory
(AssertionInfo info, File actual, FileFilter filter) Paths.filterDirectory
(AssertionInfo info, Path actual, DirectoryStream.Filter<Path> filter) private <E> List
<E> Arrays.filterElements
(AssertionInfo info, Failures failures, Conditions conditions, Object array, Condition<E> condition, boolean negateCondition) private <E> List
<E> Arrays.getElementsMatchingCondition
(AssertionInfo info, Failures failures, Conditions conditions, Object array, Condition<E> condition) private <E> List
<E> Arrays.getElementsNotMatchingCondition
(AssertionInfo info, Failures failures, Conditions conditions, Object array, Condition<E> condition) (package private) static void
Arrays2D.hasSameRowSizeAsCheck
(AssertionInfo info, int rowIndex, Object actual, Object other, Object actualRow, Object otherRow, int actualRowSize) static void
CommonValidations.hasSameSizeAsCheck
(AssertionInfo info, Object actual, Iterable<?> other, int sizeOfActual) static void
CommonValidations.hasSameSizeAsCheck
(AssertionInfo info, Object actual, Object other, int sizeOfActual) static void
CommonValidations.hasSameSizeAsCheck
(AssertionInfo info, Object actual, Map<?, ?> other, int sizeOfActual) void
Dates.hasSameTimeAs
(AssertionInfo info, Date actual, Date date) Verifies that the actualDate
is equal to the given date by comparing their time.private boolean
Objects.haveSameClass
(Object actual, Object other, AssertionInfo info) private boolean
Files.isAbsolutePath
(AssertionInfo info, File actual) private boolean
Files.isDirectoryRecursivelyContaining
(AssertionInfo info, File actual, Predicate<File> filter) private boolean
Paths.isDirectoryRecursivelyContaining
(AssertionInfo info, Path actual, Predicate<Path> filter) private boolean
Objects.isInstanceOfClass
(Object actual, Class<?> clazz, AssertionInfo info) private boolean
Objects.isOfOneOfGivenTypes
(Object actual, Class<?>[] types, AssertionInfo info) private boolean
Objects.objectIsInstanceOfOneOfGivenClasses
(Object actual, Class<?>[] types, AssertionInfo info) private PathMatcher
Paths.pathMatcher
(AssertionInfo info, Path actual, String syntaxAndPattern) <T> void
Lists.satisfies
(AssertionInfo info, List<? extends T> actual, Consumer<? super T> requirements, Index index) private AssertionError
Iterables.shouldContainExactlyWithDiffAssertionError
(IterableDiff<Object> diff, Iterable<?> actual, Object[] values, AssertionInfo info) private AssertionError
Iterables.shouldContainExactlyWithIndexAssertionError
(Iterable<?> actual, Object[] values, List<IndexedDiff> indexedDiffs, AssertionInfo info)