Uses of Interface
org.fest.assertions.core.AssertionInfo
Packages that use AssertionInfo
-
Uses of AssertionInfo in org.fest.assertions.core
Classes in org.fest.assertions.core that implement AssertionInfoModifier and TypeClassDescriptionclass
Writable information about an assertion. -
Uses of AssertionInfo in org.fest.assertions.internal
Methods in org.fest.assertions.internal with parameters of type AssertionInfoModifier and TypeMethodDescription<E> void
Iterables.assertAre
(AssertionInfo info, Iterable<? extends E> actual, Condition<? super E> 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
Iterables.assertAreAtLeast
(AssertionInfo info, Iterable<? extends E> actual, int n, Condition<? super E> condition) Assert that there is 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 is at least n array elements satisfying the given condition.<E> void
Iterables.assertAreAtMost
(AssertionInfo info, Iterable<? extends E> actual, int n, Condition<? super E> condition) Assert that there is 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 is at most n array elements satisfying the given condition.<E> void
Iterables.assertAreExactly
(AssertionInfo info, Iterable<? extends E> actual, int n, Condition<? super E> condition) Verifies that there is 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 is exactly n array elements satisfying the given 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.<E> void
Iterables.assertAreNotAtLeast
(AssertionInfo info, Iterable<? extends E> actual, int n, Condition<? super E> condition) Assert that there is at least n elements in the actualIterable
not satisfying the given condition.<E> void
ObjectArrays.assertAreNotAtLeast
(AssertionInfo info, E[] actual, int n, Condition<? super E> condition) Assert that there is at least n array elements not satisfying the given condition.<E> void
Iterables.assertAreNotAtMost
(AssertionInfo info, Iterable<? extends E> actual, int n, Condition<? super E> condition) Verifies that there is at most n elements in the actualIterable
not satisfying the given condition.<E> void
ObjectArrays.assertAreNotAtMost
(AssertionInfo info, E[] actual, int n, Condition<? super E> condition) Verifies that there is at most n array elements not satisfying the given condition.<E> void
Iterables.assertAreNotExactly
(AssertionInfo info, Iterable<? extends E> actual, int n, Condition<? super E> condition) Verifies that there is exactly n elements in the actualIterable
not satisfying the given condition.<E> void
ObjectArrays.assertAreNotExactly
(AssertionInfo info, E[] actual, int n, Condition<? super E> condition) Verifies that there is exactly n elements in the actualIterable
not satisfying the given condition.void
Files.assertCanRead
(AssertionInfo info, File actual) Asserts that the given file can be read by the application.void
Files.assertCanWrite
(AssertionInfo info, File actual) Asserts that the given file can be modified by the application.void
BooleanArrays.assertContains
(AssertionInfo info, boolean[] actual, boolean[] values) Asserts that the given array contains the given values, in any order.void
BooleanArrays.assertContains
(AssertionInfo info, boolean[] actual, boolean value, Index index) Verifies that the given array contains the given value at the given index.void
ByteArrays.assertContains
(AssertionInfo info, byte[] actual, byte[] values) Asserts that the given array contains the given values, in any order.void
ByteArrays.assertContains
(AssertionInfo info, byte[] actual, byte value, Index index) Verifies that the given array contains the given value at the given index.void
CharArrays.assertContains
(AssertionInfo info, char[] actual, char[] values) Asserts that the given array contains the given values, in any order.void
CharArrays.assertContains
(AssertionInfo info, char[] actual, char value, Index index) Verifies that the given array contains the given value at the given index.void
DoubleArrays.assertContains
(AssertionInfo info, double[] actual, double[] values) Asserts that the given array contains the given values, in any order.void
DoubleArrays.assertContains
(AssertionInfo info, double[] actual, double value, Index index) Verifies that the given array contains the given value at the given index.void
FloatArrays.assertContains
(AssertionInfo info, float[] actual, float[] values) Asserts that the given array contains the given values, in any order.void
FloatArrays.assertContains
(AssertionInfo info, float[] actual, float value, Index index) Verifies that the given array contains the given value at the given index.void
IntArrays.assertContains
(AssertionInfo info, int[] actual, int[] values) Asserts that the given array contains the given values, in any order.void
IntArrays.assertContains
(AssertionInfo info, int[] actual, int value, Index index) Verifies that the given array contains the given value at the given index.void
Iterables.assertContains
(AssertionInfo info, Iterable<?> actual, Object[] values) Asserts that the givenIterable
contains the given values, in any order.void
Lists.assertContains
(AssertionInfo info, List<?> actual, Object value, Index index) Verifies that the givenList
contains the given object at the given index.void
LongArrays.assertContains
(AssertionInfo info, long[] actual, long[] values) Asserts that the given array contains the given values, in any order.void
LongArrays.assertContains
(AssertionInfo info, long[] actual, long value, Index index) Verifies that the given array contains the given value at the given index.void
Maps.assertContains
(AssertionInfo info, Map<?, ?> actual, MapEntry[] entries) Asserts that the givenMap
contains the given entries, in any order.void
ObjectArrays.assertContains
(AssertionInfo info, Object[] actual, Object[] values) Asserts that the given array contains the given values, in any order.void
ObjectArrays.assertContains
(AssertionInfo info, Object[] actual, Object value, Index index) Verifies that the given array contains the given object at the given index.void
ShortArrays.assertContains
(AssertionInfo info, short[] actual, short[] values) Asserts that the given array contains the given values, in any order.void
ShortArrays.assertContains
(AssertionInfo info, short[] actual, short value, Index index) Verifies that the given array contains the given value at the given index.void
Strings.assertContains
(AssertionInfo info, String actual, String sequence) Verifies that the givenString
contains the given sequence.void
Iterables.assertContainsAll
(AssertionInfo info, Iterable<?> actual, Iterable<?> other) Asserts that the givenIterable
contains all the elements of the otherIterable
, in any order.<E> void
ObjectArrays.assertContainsAll
(AssertionInfo info, E[] actual, Iterable<? extends E> other) Asserts that the given array contains all the elements of the givenIterable
, in any order.void
Iterables.assertContainsExactly
(AssertionInfo info, Iterable<?> actual, Object[] values) Asserts that the givenIterable
contains exactly the given values and nothing else, in order.void
Strings.assertContainsIgnoringCase
(AssertionInfo info, String actual, String sequence) Verifies that the givenString
contains the given sequence, ignoring case considerations.<K,
V> void Maps.assertContainsKey
(AssertionInfo info, Map<K, V> actual, K key) Verifies that the actual map contain the given key.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.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
CharArrays.assertContainsOnly
(AssertionInfo info, char[] actual, char[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
DoubleArrays.assertContainsOnly
(AssertionInfo info, double[] actual, double[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
FloatArrays.assertContainsOnly
(AssertionInfo info, float[] actual, float[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
IntArrays.assertContainsOnly
(AssertionInfo info, int[] actual, int[] values) Asserts that the given array contains only the given values and nothing else, in any order.void
Iterables.assertContainsOnly
(AssertionInfo info, Iterable<?> actual, Object[] values) Asserts that the givenIterable
contains only the given values and nothing else, in any order.void
LongArrays.assertContainsOnly
(AssertionInfo info, long[] actual, long[] values) Asserts that the given array contains only the given values and nothing else, in any order.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.assertContainsOnlyOnce
(AssertionInfo info, String actual, String sequence) Verifies that actualString
s contains only once the given 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
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.<K,
V> void Maps.assertContainsValue
(AssertionInfo info, Map<K, V> actual, V value) Verifies that the actual map contain the given value.void
BooleanArrays.assertDoesNotContain
(AssertionInfo info, boolean[] actual, boolean[] values) Asserts that the given array does not contain the given values.void
BooleanArrays.assertDoesNotContain
(AssertionInfo info, boolean[] actual, boolean value, Index index) Verifies that the given array does not contain the given value at the given index.void
ByteArrays.assertDoesNotContain
(AssertionInfo info, byte[] actual, byte[] values) Asserts that the given array does not contain the given values.void
ByteArrays.assertDoesNotContain
(AssertionInfo info, byte[] actual, byte value, Index index) Verifies that the given array does not contain the given value at the given index.void
CharArrays.assertDoesNotContain
(AssertionInfo info, char[] actual, char[] values) Asserts that the given array does not contain the given values.void
CharArrays.assertDoesNotContain
(AssertionInfo info, char[] actual, char value, Index index) Verifies that the given array does not contain the given value at the given index.void
DoubleArrays.assertDoesNotContain
(AssertionInfo info, double[] actual, double[] values) Asserts that the given array does not contain the given values.void
DoubleArrays.assertDoesNotContain
(AssertionInfo info, double[] actual, double value, Index index) Verifies that the given array does not contain the given value at the given index.void
FloatArrays.assertDoesNotContain
(AssertionInfo info, float[] actual, float[] values) Asserts that the given array does not contain the given values.void
FloatArrays.assertDoesNotContain
(AssertionInfo info, float[] actual, float value, Index index) Verifies that the given array does not contain the given value at the given index.void
IntArrays.assertDoesNotContain
(AssertionInfo info, int[] actual, int[] values) Asserts that the given array does not contain the given values.void
IntArrays.assertDoesNotContain
(AssertionInfo info, int[] actual, int value, Index index) Verifies that the given array does not contain the given value at the given index.void
Iterables.assertDoesNotContain
(AssertionInfo info, Iterable<?> actual, Object[] values) Asserts that the givenIterable
does not contain the given values.void
Lists.assertDoesNotContain
(AssertionInfo info, List<?> actual, Object value, Index index) Verifies that the givenList
does not contain the given object at the given index.void
LongArrays.assertDoesNotContain
(AssertionInfo info, long[] actual, long[] values) Asserts that the given array does not contain the given values.void
LongArrays.assertDoesNotContain
(AssertionInfo info, long[] actual, long value, Index index) Verifies that the given array does not contain the given value at the given index.void
Maps.assertDoesNotContain
(AssertionInfo info, Map<?, ?> actual, MapEntry[] entries) Asserts that the givenMap
does not contain the given entries.void
ObjectArrays.assertDoesNotContain
(AssertionInfo info, Object[] actual, Object[] values) Asserts that the given array does not contain the given values.void
ObjectArrays.assertDoesNotContain
(AssertionInfo info, Object[] actual, Object value, Index index) Verifies that the given array does not contain the given object at the given index.void
ShortArrays.assertDoesNotContain
(AssertionInfo info, short[] actual, short[] values) Asserts that the given array does not contain the given values.void
ShortArrays.assertDoesNotContain
(AssertionInfo info, short[] actual, short value, Index index) Verifies that the given array does not contain the given value at the given index.void
Strings.assertDoesNotContain
(AssertionInfo info, String actual, String sequence) Verifies that the givenString
does not contain the given sequence.<K,
V> void Maps.assertDoesNotContainKey
(AssertionInfo info, Map<K, V> actual, K key) Verifies that the actual map not contains the given key.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.<K,
V> void Maps.assertDoesNotContainValue
(AssertionInfo info, Map<K, V> actual, V value) Verifies that the actual map not contains the given value.void
Files.assertDoesNotExist
(AssertionInfo info, File actual) Asserts that the given file does not exist.<T> void
Conditions.assertDoesNotHave
(AssertionInfo info, T actual, Condition<? super T> condition) Asserts that the actual value does not satisfy the given
.Condition
void
BooleanArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, boolean[] actual) Asserts that the given array does not have duplicate values.void
ByteArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, byte[] actual) Asserts that the given array does not have duplicate values.void
CharArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, char[] actual) Asserts that the given array does not have duplicate values.void
DoubleArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, double[] actual) Asserts that the given array does not have duplicate values.void
FloatArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, float[] actual) Asserts that the given array does not have duplicate values.void
IntArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, int[] actual) Asserts that the given array does not have duplicate values.void
Iterables.assertDoesNotHaveDuplicates
(AssertionInfo info, Iterable<?> actual) Asserts that the givenIterable
does not have duplicate values.void
LongArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, long[] actual) Asserts that the given array does not have duplicate values.void
ObjectArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, Object[] actual) Asserts that the given array does not have duplicate values.void
ShortArrays.assertDoesNotHaveDuplicates
(AssertionInfo info, short[] actual) Asserts that the given array does not have duplicate values.void
Objects.assertDoesNotHaveSameClassAs
(AssertionInfo info, Object actual, Object other) Verifies that the actual value does not have the same class as the given object.void
Strings.assertDoesNotMatch
(AssertionInfo info, String actual, String regex) Verifies that the givenString
does not match the given regular expression.void
Strings.assertDoesNotMatch
(AssertionInfo info, String actual, Pattern pattern) Verifies that the givenString
does not match the given regular expression.<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.<E> void
Iterables.assertDoNotHaveAtLeast
(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition) An alias method ofIterables.assertAreNotAtLeast(AssertionInfo, Iterable, int, Condition)
to provide a richer fluent api (same logic, only error message differs).<E> void
ObjectArrays.assertDoNotHaveAtLeast
(AssertionInfo info, E[] actual, int times, Condition<? super E> condition) An alias method ofObjectArrays.assertAreNotAtLeast(AssertionInfo, Object[], int, Condition)
to provide a richer fluent api (same logic, only error message differs).<E> void
Iterables.assertDoNotHaveAtMost
(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition) An alias method ofIterables.assertAreNotAtMost(AssertionInfo, Iterable, int, Condition)
to provide a richer fluent api (same logic, only error message differs).<E> void
ObjectArrays.assertDoNotHaveAtMost
(AssertionInfo info, E[] actual, int times, Condition<? super E> condition) An alias method ofObjectArrays.assertAreNotAtMost(AssertionInfo, Object[], int, Condition)
to provide a richer fluent api (same logic, only error message differs).<E> void
Iterables.assertDoNotHaveExactly
(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition) An alias method ofIterables.assertAreNotExactly(AssertionInfo, Iterable, int, Condition)
to provide a richer fluent api (same logic, only error message differs).<E> void
ObjectArrays.assertDoNotHaveExactly
(AssertionInfo info, E[] actual, int times, Condition<? super E> condition) An alias method ofObjectArrays.assertAreNotExactly(AssertionInfo, Object[], int, Condition)
to provide a richer fluent api (same logic, only error message differs).void
BooleanArrays.assertEmpty
(AssertionInfo info, boolean[] actual) Asserts that the given array is empty.void
ByteArrays.assertEmpty
(AssertionInfo info, byte[] actual) Asserts that the given array is empty.void
CharArrays.assertEmpty
(AssertionInfo info, char[] actual) Asserts that the given array is empty.void
DoubleArrays.assertEmpty
(AssertionInfo info, double[] actual) Asserts that the given array is empty.void
FloatArrays.assertEmpty
(AssertionInfo info, float[] actual) Asserts that the given array is empty.void
IntArrays.assertEmpty
(AssertionInfo info, int[] actual) Asserts that the given array is empty.void
Iterables.assertEmpty
(AssertionInfo info, Iterable<?> actual) Asserts that the givenIterable
is empty.void
LongArrays.assertEmpty
(AssertionInfo info, long[] actual) Asserts that the given array is empty.void
Maps.assertEmpty
(AssertionInfo info, Map<?, ?> actual) Asserts that the givenMap
is empty.void
ObjectArrays.assertEmpty
(AssertionInfo info, Object[] actual) Asserts that the given array is empty.void
ShortArrays.assertEmpty
(AssertionInfo info, short[] actual) Asserts that the given array is empty.void
Strings.assertEmpty
(AssertionInfo info, String actual) Asserts that the givenString
is empty.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
CharArrays.assertEndsWith
(AssertionInfo info, char[] actual, char[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
DoubleArrays.assertEndsWith
(AssertionInfo info, double[] actual, double[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
FloatArrays.assertEndsWith
(AssertionInfo info, float[] actual, float[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
IntArrays.assertEndsWith
(AssertionInfo info, int[] actual, int[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
Iterables.assertEndsWith
(AssertionInfo info, Iterable<?> actual, Object[] sequence) Verifies that the givenIterable
ends with the given sequence of objects, without any other objects between them.void
LongArrays.assertEndsWith
(AssertionInfo info, long[] actual, long[] sequence) Verifies that the given array ends with the given sequence of values, without any other values between them.void
ObjectArrays.assertEndsWith
(AssertionInfo info, Object[] actual, Object[] sequence) Verifies that the given array ends with the given sequence of objects, without any other objects between them.void
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, String actual, String suffix) Verifies that the givenString
ends with the given suffix.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
Doubles.assertEqual
(AssertionInfo info, Double actual, Double expected, Offset<Double> offset) Verifies that two floats are equal within a positive offset.
It does not rely on the custom comparisonStrategy (if one is set) because using an offset is already a specific comparison strategy.void
Floats.assertEqual
(AssertionInfo info, Float actual, Float expected, Offset<Float> offset) Verifies that two floats are equal within a positive offset.
It does not rely on the custom comparisonStrategy (if one is set) because using an offset is already a specific comparison strategy.void
Objects.assertEqual
(AssertionInfo info, Object actual, Object expected) Asserts that two objects are equal.<T extends Comparable<? super T>>
voidComparables.assertEqualByComparison
(AssertionInfo info, T actual, T expected) Asserts that two
s are equal by invokingComparable
.Comparable.compareTo(Object)
Note that it does not rely on the customComparables.comparisonStrategy
if one has been set.void
Files.assertEqualContent
(AssertionInfo info, File actual, File expected) Asserts that the given files have equal content.void
InputStreams.assertEqualContent
(AssertionInfo info, InputStream actual, InputStream expected) Asserts that the given InputStreams have equal content.void
Strings.assertEqualsIgnoringCase
(AssertionInfo info, String actual, String expected) Verifies that twoString
s are equal, ignoring case considerations.void
Files.assertExists
(AssertionInfo info, File actual) Asserts that the given file exists, regardless it's a file or directory.<T extends Comparable<? super T>>
voidComparables.assertGreaterThan
(AssertionInfo info, T actual, T other) Asserts that the actual value is greater than the other one.<T extends Comparable<? super T>>
voidComparables.assertGreaterThanOrEqualTo
(AssertionInfo info, T actual, T other) Asserts that the actual value is greater than or equal to the other one.<T> void
Conditions.assertHas
(AssertionInfo info, T actual, Condition<? super T> condition) Asserts that the actual value satisfies the given
.Condition
<T> void
Lists.assertHas
(AssertionInfo info, List<T> actual, Condition<? super T> condition, Index index) Verifies that the givenList
satisfies the given
at the given index.Condition
void
Files.assertHasBinaryContent
(AssertionInfo info, File actual, byte[] expected) Asserts that the given file has the given binary content.void
Files.assertHasContent
(AssertionInfo info, File actual, String expected, Charset charset) Asserts that the given file has the given text content.void
Throwables.assertHasMessage
(AssertionInfo info, Throwable actual, String message) Asserts that the given actualThrowable
message is equal to the given one.void
Throwables.assertHasMessageContaining
(AssertionInfo info, Throwable actual, String description) Asserts that the message of the actualThrowable
contains with the given description.void
Throwables.assertHasMessageEndingWith
(AssertionInfo info, Throwable actual, String description) Asserts that the message of the actualThrowable
ends with the given description.void
Throwables.assertHasMessageStartingWith
(AssertionInfo info, Throwable actual, String description) Asserts that the message of the actualThrowable
starts with the given description.void
Throwables.assertHasNoCause
(AssertionInfo info, Throwable actual) Asserts that the actualThrowable
does not have a cause.void
Objects.assertHasSameClassAs
(AssertionInfo info, Object actual, Object other) Verifies that the actual value has the same class as the given object.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
ByteArrays.assertHasSameSizeAs
(AssertionInfo info, byte[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
CharArrays.assertHasSameSizeAs
(AssertionInfo info, char[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
CharArrays.assertHasSameSizeAs
(AssertionInfo info, char[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
DoubleArrays.assertHasSameSizeAs
(AssertionInfo info, double[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
DoubleArrays.assertHasSameSizeAs
(AssertionInfo info, double[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
FloatArrays.assertHasSameSizeAs
(AssertionInfo info, float[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
FloatArrays.assertHasSameSizeAs
(AssertionInfo info, float[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
IntArrays.assertHasSameSizeAs
(AssertionInfo info, int[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
IntArrays.assertHasSameSizeAs
(AssertionInfo info, int[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
Iterables.assertHasSameSizeAs
(AssertionInfo info, Iterable<?> actual, Iterable<?> other) Assert that the actualIterable
has the same size as the otherIterable
.void
Iterables.assertHasSameSizeAs
(AssertionInfo info, Iterable<?> actual, Object[] other) Assert that the actualIterable
has the same size as the other array.void
LongArrays.assertHasSameSizeAs
(AssertionInfo info, long[] actual, Iterable<?> other) Assert that the actual array has the same size as the otherIterable
.void
LongArrays.assertHasSameSizeAs
(AssertionInfo info, long[] actual, Object[] other) Assert that the actual array has the same size as the other array.void
Maps.assertHasSameSizeAs
(AssertionInfo info, Map<?, ?> map, Iterable<?> other) Asserts that the number of entries in the givenMap
has the same size as the otherIterable
.void
Maps.assertHasSameSizeAs
(AssertionInfo info, Map<?, ?> map, Object[] other) Asserts that the number of entries in the givenMap
has the same size as the other array.void
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, String actual, Iterable<?> other) Asserts that the number of entries in the givenString
has the same size as the otherIterable
.void
Strings.assertHasSameSizeAs
(AssertionInfo info, String actual, Object[] other) Asserts that the number of entries in the givenString
has the same size as the other array.void
BooleanArrays.assertHasSize
(AssertionInfo info, boolean[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
ByteArrays.assertHasSize
(AssertionInfo info, byte[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
CharArrays.assertHasSize
(AssertionInfo info, char[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
DoubleArrays.assertHasSize
(AssertionInfo info, double[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
FloatArrays.assertHasSize
(AssertionInfo info, float[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
IntArrays.assertHasSize
(AssertionInfo info, int[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
Iterables.assertHasSize
(AssertionInfo info, Iterable<?> actual, int expectedSize) Asserts that the number of elements in the givenIterable
is equal to the expected one.void
LongArrays.assertHasSize
(AssertionInfo info, long[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
Maps.assertHasSize
(AssertionInfo info, Map<?, ?> actual, int expectedSize) Asserts that the number of entries in the givenMap
is equal to the expected one.void
ObjectArrays.assertHasSize
(AssertionInfo info, Object[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
ShortArrays.assertHasSize
(AssertionInfo info, short[] actual, int expectedSize) Asserts that the number of elements in the given array is equal to the expected one.void
Strings.assertHasSize
(AssertionInfo info, String actual, int expectedSize) Asserts that the size of the givenString
is equal to the expected one.void
Dates.assertHasTime
(AssertionInfo info, Date actual, long timestamp) Verifies that the actualDate
time is equal to the given timestamp.<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
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
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
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).<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<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
Dates.assertIsAfter
(AssertionInfo info, Date actual, Date other) Verifies that the actualDate
is strictly after the given one.void
Dates.assertIsAfterOrEqualsTo
(AssertionInfo info, Date actual, Date other) Verifies that the actualDate
is after or equal to the given one.void
Dates.assertIsAfterYear
(AssertionInfo info, Date actual, int year) Verifies that the actualDate
is strictly after the given year.void
Dates.assertIsBefore
(AssertionInfo info, Date actual, Date other) Verifies that the actualDate
is strictly before the given one.void
Dates.assertIsBeforeOrEqualsTo
(AssertionInfo info, Date actual, Date other) Verifies that the actualDate
is before or equal to the given one.void
Dates.assertIsBeforeYear
(AssertionInfo info, Date actual, int year) Verifies that the actualDate
is strictly before the given year.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
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
Files.assertIsDirectory
(AssertionInfo info, File actual) Asserts that the given file is an existing directory.void
Objects.assertIsExactlyInstanceOf
(AssertionInfo info, Object actual, Class<?> type) Verifies that the actual value is exactly a instance of given type.void
Files.assertIsFile
(AssertionInfo info, File actual) Asserts that the given file is an existing file.<A> void
Objects.assertIsIn
(AssertionInfo info, A actual, Iterable<? extends A> values) Asserts that the given object is present in the given collection.void
Objects.assertIsIn
(AssertionInfo info, Object actual, Object[] values) Asserts that the given object is present in the given array.void
Dates.assertIsInSameDayAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are chronologically in the same day of month (and thus in the same month and year).void
Dates.assertIsInSameHourAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are chronologically in the same hour (and thus in the same day of month, month and year).void
Dates.assertIsInSameMinuteAs
(AssertionInfo info, Date actual, Date other) Verifies that actual and givenDate
are chronologically in the same minute (and thus in the same hour, day of month, month and year).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 chronologically in the same second (and thus in the same minute, hour, day of month, month and year).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
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.<A> void
Objects.assertIsLenientEqualsToByAcceptingFields
(AssertionInfo info, A actual, A other, String... fields) Assert that the given object is lenient equals to other object by comparing given fields value only.<A> void
Objects.assertIsLenientEqualsToByIgnoringFields
(AssertionInfo info, A actual, A other, String... fields) Assert that the given object is lenient equals to the other by comparing all fields (including inherited fields) unless given ignored ones.<A> void
Objects.assertIsLenientEqualsToByIgnoringNullFields
(AssertionInfo info, A actual, A other) Assert that the given object is lenient equals by ignoring null fields value on other object (including inherited fields).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.<T> void
Conditions.assertIsNot
(AssertionInfo info, T actual, Condition<? super T> condition) Asserts that the actual value does not satisfy the given
.Condition
void
Dates.assertIsNotBetween
(AssertionInfo info, Date actual, Date start, Date end, boolean inclusiveStart, boolean inclusiveEnd) Verifies that the 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
Objects.assertIsNotExactlyInstanceOf
(AssertionInfo info, Object actual, Class<?> type) Verifies that the actual value is not exactly a instance of given type.<A> void
Objects.assertIsNotIn
(AssertionInfo info, A actual, Iterable<? extends A> values) Asserts that the given object is not present in the given collection.void
Objects.assertIsNotIn
(AssertionInfo info, Object actual, Object[] values) Asserts that the given object is not present in the given array.void
Objects.assertIsNotInstanceOf
(AssertionInfo info, Object actual, Class<?> type) Verifies that the given object is not an instance of the given type.void
Objects.assertIsNotInstanceOfAny
(AssertionInfo info, Object actual, Class<?>[] types) Verifies that the given object is not an instance of any of the given types.void
RealNumbers.assertIsNotNaN
(AssertionInfo info, NUMBER actual) Verifies that the actual value is not equal toNaN
.void
Numbers.assertIsNotNegative
(AssertionInfo info, NUMBER actual) Asserts that the actual value is not negative.void
Objects.assertIsNotOfAnyClassIn
(AssertionInfo info, Object actual, Class<?>[] types) Verifies that the actual value type is not in given types.void
Numbers.assertIsNotPositive
(AssertionInfo info, NUMBER actual) Asserts that the actual value is not positive.void
Numbers.assertIsNotZero
(AssertionInfo info, NUMBER actual) Asserts that the actual value is not equal to zero.
It does not rely on the custom comparisonStrategy (if one is set).void
Objects.assertIsOfAnyClassIn
(AssertionInfo info, Object actual, Class<?>[] types) Verifies that the actual value type is in given types.void
Numbers.assertIsPositive
(AssertionInfo info, NUMBER actual) Asserts that the actual value is positive.void
Files.assertIsRelative
(AssertionInfo info, File actual) Asserts that the given file is a relative path.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 into 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()
.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<? extends Object> 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 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
Iterables.assertIsSubsetOf
(AssertionInfo info, Iterable<?> actual, Iterable<?> values) Verifies that the actualIterable
is a subset of valuesIterable
.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
Dates.assertIsWithinDayOfMonth
(AssertionInfo info, Date actual, int dayOfMonth) Verifies that the actualDate
day of month is equal to the given day of month.void
Dates.assertIsWithinDayOfWeek
(AssertionInfo info, Date actual, int dayOfWeek) Verifies that the actualDate
day of week is equal to the given day of week.void
Dates.assertIsWithinHourOfDay
(AssertionInfo info, Date actual, int hourOfDay) Verifies that the actualDate
hour od day is equal to the given hour of day (24-hour clock).void
Dates.assertIsWithinMillisecond
(AssertionInfo info, Date actual, int millisecond) Verifies that the actualDate
millisecond is equal to the given millisecond.void
Dates.assertIsWithinMinute
(AssertionInfo info, Date actual, int minute) Verifies that the actualDate
minute is equal to the given minute.void
Dates.assertIsWithinMonth
(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
Dates.assertIsWithinSecond
(AssertionInfo info, Date actual, int second) Verifies that the actualDate
second is equal to the given second.void
Dates.assertIsWithinYear
(AssertionInfo info, Date actual, int year) Verifies that the actualDate
year is equal to the given year.void
Numbers.assertIsZero
(AssertionInfo info, NUMBER actual) Asserts that the actual value is equal to zero.
It does not rely on the custom comparisonStrategy (if one is set).<T extends Comparable<? super T>>
voidComparables.assertLessThan
(AssertionInfo info, T actual, T other) Asserts that the actual value is less than the other one.<T extends Comparable<? super T>>
voidComparables.assertLessThanOrEqualTo
(AssertionInfo info, T actual, T other) Asserts that the actual value is less than or equal to the other one.void
Characters.assertLowerCase
(AssertionInfo info, Character actual) Asserts that the actual value is a lowercase character.void
Strings.assertMatches
(AssertionInfo info, String actual, String regex) Verifies that the givenString
matches the given regular expression.void
Strings.assertMatches
(AssertionInfo info, String actual, Pattern pattern) Verifies that the givenString
matches the given regular expression.void
BooleanArrays.assertNotEmpty
(AssertionInfo info, boolean[] actual) Asserts that the given array is not empty.void
ByteArrays.assertNotEmpty
(AssertionInfo info, byte[] actual) Asserts that the given array is not empty.void
CharArrays.assertNotEmpty
(AssertionInfo info, char[] actual) Asserts that the given array is not empty.void
DoubleArrays.assertNotEmpty
(AssertionInfo info, double[] actual) Asserts that the given array is not empty.void
FloatArrays.assertNotEmpty
(AssertionInfo info, float[] actual) Asserts that the given array is not empty.void
IntArrays.assertNotEmpty
(AssertionInfo info, int[] actual) Asserts that the given array is not empty.void
Iterables.assertNotEmpty
(AssertionInfo info, Iterable<?> actual) Asserts that the givenIterable
is not empty.void
LongArrays.assertNotEmpty
(AssertionInfo info, long[] actual) Asserts that the given array is not empty.void
Maps.assertNotEmpty
(AssertionInfo info, Map<?, ?> actual) Asserts that the givenMap
is not empty.void
ObjectArrays.assertNotEmpty
(AssertionInfo info, Object[] actual) Asserts that the given array is not empty.void
ShortArrays.assertNotEmpty
(AssertionInfo info, short[] actual) Asserts that the given array is not empty.void
Strings.assertNotEmpty
(AssertionInfo info, String actual) Asserts that the givenString
is not empty.void
Booleans.assertNotEqual
(AssertionInfo info, Boolean actual, boolean other) Asserts that two longs are not equal.<T> void
Comparables.assertNotEqual
(AssertionInfo info, T actual, T other) Asserts that two T instances are not equal.void
Objects.assertNotEqual
(AssertionInfo info, Object actual, Object other) Asserts that two objects are not equal.<T extends Comparable<? super T>>
voidComparables.assertNotEqualByComparison
(AssertionInfo info, T actual, T other) Asserts that two
s are not equal by invokingComparable
.Comparable.compareTo(Object)
Note that it does not rely on the customComparables.comparisonStrategy
if one has been set.protected static <T> void
Comparables.assertNotNull
(AssertionInfo info, T actual) void
Objects.assertNotNull
(AssertionInfo info, Object actual) Asserts that the given object is notnull
.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
.void
BooleanArrays.assertNullOrEmpty
(AssertionInfo info, boolean[] actual) Asserts that the given array isnull
or empty.void
ByteArrays.assertNullOrEmpty
(AssertionInfo info, byte[] actual) Asserts that the given array isnull
or empty.void
CharArrays.assertNullOrEmpty
(AssertionInfo info, char[] actual) Asserts that the given array isnull
or empty.void
DoubleArrays.assertNullOrEmpty
(AssertionInfo info, double[] actual) Asserts that the given array isnull
or empty.void
FloatArrays.assertNullOrEmpty
(AssertionInfo info, float[] actual) Asserts that the given array isnull
or empty.void
IntArrays.assertNullOrEmpty
(AssertionInfo info, int[] actual) Asserts that the given array isnull
or empty.void
Iterables.assertNullOrEmpty
(AssertionInfo info, Iterable<?> actual) Asserts that the given
isIterable
null
or empty.void
LongArrays.assertNullOrEmpty
(AssertionInfo info, long[] actual) Asserts that the given array isnull
or empty.void
Maps.assertNullOrEmpty
(AssertionInfo info, Map<?, ?> actual) Asserts that the givenMap
isnull
or empty.void
ObjectArrays.assertNullOrEmpty
(AssertionInfo info, Object[] actual) Asserts that the given array isnull
or empty.void
ShortArrays.assertNullOrEmpty
(AssertionInfo info, short[] actual) Asserts that the given array isnull
or empty.void
Strings.assertNullOrEmpty
(AssertionInfo info, String actual) Asserts that the givenString
isnull
or empty.void
Objects.assertSame
(AssertionInfo info, Object actual, Object expected) Asserts that two objects refer to the same object.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
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
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, String actual, String prefix) Verifies that the givenString
starts with the given prefix.void
Characters.assertUpperCase
(AssertionInfo info, Character actual) Asserts that the actual value is a uppercase character.Failures.failure
(AssertionInfo info, AssertionErrorFactory factory) Creates a
following this pattern: creates aAssertionError
usingAssertionError
as the error message if such value is notoverridingErrorMessage()
null
, or uses the given
to create anAssertionErrorFactory
, prepending the value ofAssertionError
to the error messagedescription()
Failures.failure
(AssertionInfo info, ErrorMessageFactory message) Creates a
following this pattern: creates aAssertionError
usingAssertionError
as the error message if such value is notoverridingErrorMessage()
null
, or uses the given
to create the detail message of theErrorMessageFactory
, prepending the value ofAssertionError
to the error messagedescription()