<E> void |
Iterables.assertAre(AssertionInfo info,
java.lang.Iterable<? extends E> actual,
Condition<? super E> condition) |
Assert that each element of given Iterable satisfies the given condition.
|
<E> void |
ObjectArrays.assertAre(AssertionInfo info,
E[] actual,
Condition<? super E> condition) |
Assert that each element of given array satisfies the given condition.
|
<E> void |
Iterables.assertAreAtLeast(AssertionInfo info,
java.lang.Iterable<? extends E> actual,
int n,
Condition<? super E> condition) |
Assert that there is at least n elements in the actual Iterable satisfying the given
condition.
|
<E> void |
ObjectArrays.assertAreAtLeast(AssertionInfo info,
E[] actual,
int n,
Condition<? super E> condition) |
Assert that there is at least n array elements satisfying the given condition.
|
<E> void |
Iterables.assertAreAtMost(AssertionInfo info,
java.lang.Iterable<? extends E> actual,
int n,
Condition<? super E> condition) |
Assert that there is at most n elements in the actual Iterable satisfying the given
condition.
|
<E> void |
ObjectArrays.assertAreAtMost(AssertionInfo info,
E[] actual,
int n,
Condition<? super E> condition) |
Assert that there is at most n array elements satisfying the given condition.
|
<E> void |
Iterables.assertAreExactly(AssertionInfo info,
java.lang.Iterable<? extends E> actual,
int n,
Condition<? super E> condition) |
Verifies that there is exactly n elements in the actual Iterable satisfying the given
condition.
|
<E> void |
ObjectArrays.assertAreExactly(AssertionInfo info,
E[] actual,
int n,
Condition<? super E> condition) |
Verifies that there is exactly n array elements satisfying the given condition.
|
<E> void |
Iterables.assertAreNot(AssertionInfo info,
java.lang.Iterable<? extends E> actual,
Condition<? super E> condition) |
Assert that each element of given Iterable not satisfies the given condition.
|
<E> void |
ObjectArrays.assertAreNot(AssertionInfo info,
E[] actual,
Condition<? super E> condition) |
Assert that each element of given array not satisfies the given condition.
|
<E> void |
Iterables.assertAreNotAtLeast(AssertionInfo info,
java.lang.Iterable<? extends E> actual,
int n,
Condition<? super E> condition) |
Assert that there is at least n elements in the actual Iterable 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,
java.lang.Iterable<? extends E> actual,
int n,
Condition<? super E> condition) |
Verifies that there is at most n elements in the actual Iterable 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,
java.lang.Iterable<? extends E> actual,
int n,
Condition<? super E> condition) |
Verifies that there is exactly n elements in the actual Iterable 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 actual Iterable not satisfying the given
condition.
|
void |
Files.assertCanRead(AssertionInfo info,
java.io.File actual) |
Asserts that the given file can be read by the application.
|
void |
Files.assertCanWrite(AssertionInfo info,
java.io.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,
java.lang.Iterable<?> actual,
java.lang.Object[] values) |
Asserts that the given Iterable contains the given values, in any order.
|
void |
Lists.assertContains(AssertionInfo info,
java.util.List<?> actual,
java.lang.Object value,
Index index) |
Verifies that the given List 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,
java.util.Map<?,?> actual,
MapEntry[] entries) |
Asserts that the given Map contains the given entries, in any order.
|
void |
ObjectArrays.assertContains(AssertionInfo info,
java.lang.Object[] actual,
java.lang.Object[] values) |
Asserts that the given array contains the given values, in any order.
|
void |
ObjectArrays.assertContains(AssertionInfo info,
java.lang.Object[] actual,
java.lang.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,
java.lang.String actual,
java.lang.String sequence) |
Verifies that the given String contains the given sequence.
|
void |
Iterables.assertContainsAll(AssertionInfo info,
java.lang.Iterable<?> actual,
java.lang.Iterable<?> other) |
Asserts that the given Iterable contains all the elements of the other Iterable, in any order.
|
<E> void |
ObjectArrays.assertContainsAll(AssertionInfo info,
E[] actual,
java.lang.Iterable<? extends E> other) |
Asserts that the given array contains all the elements of the given Iterable, in any order.
|
void |
Iterables.assertContainsExactly(AssertionInfo info,
java.lang.Iterable<?> actual,
java.lang.Object[] values) |
Asserts that the given Iterable contains exactly the given values and nothing else, in order.
|
void |
Strings.assertContainsIgnoringCase(AssertionInfo info,
java.lang.String actual,
java.lang.String sequence) |
Verifies that the given String contains the given sequence, ignoring case considerations.
|
<K,V>
void |
Maps.assertContainsKey(AssertionInfo info,
java.util.Map<K,V> actual,
K key) |
Verifies that the actual map contain the given key.
|
void |
Iterables.assertContainsNull(AssertionInfo info,
java.lang.Iterable<?> actual) |
Asserts that the given Iterable contains at least a null element.
|
void |
ObjectArrays.assertContainsNull(AssertionInfo info,
java.lang.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,
java.lang.Iterable<?> actual,
java.lang.Object[] values) |
Asserts that the given Iterable contains only the given values and nothing else, in any order.
|
void |
LongArrays.assertContainsOnly(AssertionInfo info,
long[] actual,
long[] values) |
Asserts that the given array contains only the given values and nothing else, in any order.
|
void |
ObjectArrays.assertContainsOnly(AssertionInfo info,
java.lang.Object[] actual,
java.lang.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,
java.lang.String actual,
java.lang.String sequence) |
Verifies that actual Strings 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,
java.lang.Iterable<?> actual,
java.lang.Object[] sequence) |
Verifies that the given 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,
java.lang.Object[] actual,
java.lang.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,
java.util.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,
java.lang.Iterable<?> actual,
java.lang.Object[] values) |
Asserts that the given Iterable does not contain the given values.
|
void |
Lists.assertDoesNotContain(AssertionInfo info,
java.util.List<?> actual,
java.lang.Object value,
Index index) |
Verifies that the given List 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,
java.util.Map<?,?> actual,
MapEntry[] entries) |
Asserts that the given Map does not contain the given entries.
|
void |
ObjectArrays.assertDoesNotContain(AssertionInfo info,
java.lang.Object[] actual,
java.lang.Object[] values) |
Asserts that the given array does not contain the given values.
|
void |
ObjectArrays.assertDoesNotContain(AssertionInfo info,
java.lang.Object[] actual,
java.lang.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,
java.lang.String actual,
java.lang.String sequence) |
Verifies that the given String does not contain the given sequence.
|
<K,V>
void |
Maps.assertDoesNotContainKey(AssertionInfo info,
java.util.Map<K,V> actual,
K key) |
Verifies that the actual map not contains the given key.
|
void |
Iterables.assertDoesNotContainNull(AssertionInfo info,
java.lang.Iterable<?> actual) |
Asserts that the given Iterable does not contain null elements.
|
void |
ObjectArrays.assertDoesNotContainNull(AssertionInfo info,
java.lang.Object[] actual) |
Asserts that the given array does not contain null elements.
|
<K,V>
void |
Maps.assertDoesNotContainValue(AssertionInfo info,
java.util.Map<K,V> actual,
V value) |
Verifies that the actual map not contains the given value.
|
void |
Files.assertDoesNotExist(AssertionInfo info,
java.io.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,
java.lang.Iterable<?> actual) |
Asserts that the given Iterable does not have duplicate values.
|
void |
LongArrays.assertDoesNotHaveDuplicates(AssertionInfo info,
long[] actual) |
Asserts that the given array does not have duplicate values.
|
void |
ObjectArrays.assertDoesNotHaveDuplicates(AssertionInfo info,
java.lang.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,
java.lang.Object actual,
java.lang.Object other) |
Verifies that the actual value does not have the same class as the given object.
|
void |
Strings.assertDoesNotMatch(AssertionInfo info,
java.lang.String actual,
java.lang.String regex) |
Verifies that the given String does not match the given regular expression.
|
void |
Strings.assertDoesNotMatch(AssertionInfo info,
java.lang.String actual,
java.util.regex.Pattern pattern) |
Verifies that the given String does not match the given regular expression.
|
<E> void |
Iterables.assertDoNotHave(AssertionInfo info,
java.lang.Iterable<? extends E> actual,
Condition<? super E> condition) |
Assert that each element of given Iterable not satisfies the given condition.
|
<E> void |
ObjectArrays.assertDoNotHave(AssertionInfo info,
E[] actual,
Condition<? super E> condition) |
Assert that each element of given array not satisfies the given condition.
|
<E> void |
Iterables.assertDoNotHaveAtLeast(AssertionInfo info,
java.lang.Iterable<? extends E> actual,
int times,
Condition<? super E> condition) |
|
<E> void |
ObjectArrays.assertDoNotHaveAtLeast(AssertionInfo info,
E[] actual,
int times,
Condition<? super E> condition) |
|
<E> void |
Iterables.assertDoNotHaveAtMost(AssertionInfo info,
java.lang.Iterable<? extends E> actual,
int times,
Condition<? super E> condition) |
|
<E> void |
ObjectArrays.assertDoNotHaveAtMost(AssertionInfo info,
E[] actual,
int times,
Condition<? super E> condition) |
|
<E> void |
Iterables.assertDoNotHaveExactly(AssertionInfo info,
java.lang.Iterable<? extends E> actual,
int times,
Condition<? super E> condition) |
|
<E> void |
ObjectArrays.assertDoNotHaveExactly(AssertionInfo info,
E[] actual,
int times,
Condition<? super E> condition) |
|
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,
java.lang.Iterable<?> actual) |
Asserts that the given Iterable is empty.
|
void |
LongArrays.assertEmpty(AssertionInfo info,
long[] actual) |
Asserts that the given array is empty.
|
void |
Maps.assertEmpty(AssertionInfo info,
java.util.Map<?,?> actual) |
Asserts that the given Map is empty.
|
void |
ObjectArrays.assertEmpty(AssertionInfo info,
java.lang.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,
java.lang.String actual) |
Asserts that the given String 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,
java.lang.Iterable<?> actual,
java.lang.Object[] sequence) |
Verifies that the given Iterable ends with the given sequence of objects, without any other objects between
them.
|
void |
LongArrays.assertEndsWith(AssertionInfo info,
long[] actual,
long[] sequence) |
Verifies that the given array ends with the given sequence of values, without any other values between them.
|
void |
ObjectArrays.assertEndsWith(AssertionInfo info,
java.lang.Object[] actual,
java.lang.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,
java.lang.String actual,
java.lang.String suffix) |
Verifies that the given String ends with the given suffix.
|
void |
Booleans.assertEqual(AssertionInfo info,
java.lang.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,
java.lang.Double actual,
java.lang.Double expected,
Offset<java.lang.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,
java.lang.Float actual,
java.lang.Float expected,
Offset<java.lang.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,
java.lang.Object actual,
java.lang.Object expected) |
Asserts that two objects are equal.
|
<T extends java.lang.Comparable<? super T>>
void |
Comparables.assertEqualByComparison(AssertionInfo info,
T actual,
T expected) |
Asserts that two Comparables are equal by invoking Comparable.compareTo(Object).
Note that it does not rely on the custom Comparables.comparisonStrategy if one has been set. |
void |
Files.assertEqualContent(AssertionInfo info,
java.io.File actual,
java.io.File expected) |
Asserts that the given files have equal content.
|
void |
InputStreams.assertEqualContent(AssertionInfo info,
java.io.InputStream actual,
java.io.InputStream expected) |
Asserts that the given InputStreams have equal content.
|
void |
Strings.assertEqualsIgnoringCase(AssertionInfo info,
java.lang.String actual,
java.lang.String expected) |
Verifies that two Strings are equal, ignoring case considerations.
|
void |
Files.assertExists(AssertionInfo info,
java.io.File actual) |
Asserts that the given file exists, regardless it's a file or directory.
|
<T extends java.lang.Comparable<? super T>>
void |
Comparables.assertGreaterThan(AssertionInfo info,
T actual,
T other) |
Asserts that the actual value is greater than the other one.
|
<T extends java.lang.Comparable<? super T>>
void |
Comparables.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,
java.util.List<T> actual,
Condition<? super T> condition,
Index index) |
Verifies that the given List satisfies the given Condition at the given index. |
void |
Files.assertHasBinaryContent(AssertionInfo info,
java.io.File actual,
byte[] expected) |
Asserts that the given file has the given binary content.
|
void |
Files.assertHasContent(AssertionInfo info,
java.io.File actual,
java.lang.String expected,
java.nio.charset.Charset charset) |
Asserts that the given file has the given text content.
|
void |
Throwables.assertHasMessage(AssertionInfo info,
java.lang.Throwable actual,
java.lang.String message) |
Asserts that the given actual Throwable message is equal to the given one.
|
void |
Throwables.assertHasMessageContaining(AssertionInfo info,
java.lang.Throwable actual,
java.lang.String description) |
Asserts that the message of the actual Throwable contains with the given description.
|
void |
Throwables.assertHasMessageEndingWith(AssertionInfo info,
java.lang.Throwable actual,
java.lang.String description) |
Asserts that the message of the actual Throwable ends with the given description.
|
void |
Throwables.assertHasMessageStartingWith(AssertionInfo info,
java.lang.Throwable actual,
java.lang.String description) |
Asserts that the message of the actual Throwable starts with the given description.
|
void |
Throwables.assertHasNoCause(AssertionInfo info,
java.lang.Throwable actual) |
Asserts that the actual Throwable does not have a cause.
|
void |
Objects.assertHasSameClassAs(AssertionInfo info,
java.lang.Object actual,
java.lang.Object other) |
Verifies that the actual value has the same class as the given object.
|
void |
BooleanArrays.assertHasSameSizeAs(AssertionInfo info,
boolean[] actual,
java.lang.Iterable<?> other) |
Assert that the actual array has the same size as the other Iterable.
|
void |
BooleanArrays.assertHasSameSizeAs(AssertionInfo info,
boolean[] actual,
java.lang.Object[] other) |
Assert that the actual array has the same size as the other array.
|
void |
ByteArrays.assertHasSameSizeAs(AssertionInfo info,
byte[] actual,
java.lang.Iterable<?> other) |
Assert that the actual array has the same size as the other Iterable.
|
void |
ByteArrays.assertHasSameSizeAs(AssertionInfo info,
byte[] actual,
java.lang.Object[] other) |
Assert that the actual array has the same size as the other array.
|
void |
CharArrays.assertHasSameSizeAs(AssertionInfo info,
char[] actual,
java.lang.Iterable<?> other) |
Assert that the actual array has the same size as the other Iterable.
|
void |
CharArrays.assertHasSameSizeAs(AssertionInfo info,
char[] actual,
java.lang.Object[] other) |
Assert that the actual array has the same size as the other array.
|
void |
DoubleArrays.assertHasSameSizeAs(AssertionInfo info,
double[] actual,
java.lang.Iterable<?> other) |
Assert that the actual array has the same size as the other Iterable.
|
void |
DoubleArrays.assertHasSameSizeAs(AssertionInfo info,
double[] actual,
java.lang.Object[] other) |
Assert that the actual array has the same size as the other array.
|
void |
FloatArrays.assertHasSameSizeAs(AssertionInfo info,
float[] actual,
java.lang.Iterable<?> other) |
Assert that the actual array has the same size as the other Iterable.
|
void |
FloatArrays.assertHasSameSizeAs(AssertionInfo info,
float[] actual,
java.lang.Object[] other) |
Assert that the actual array has the same size as the other array.
|
void |
IntArrays.assertHasSameSizeAs(AssertionInfo info,
int[] actual,
java.lang.Iterable<?> other) |
Assert that the actual array has the same size as the other Iterable.
|
void |
IntArrays.assertHasSameSizeAs(AssertionInfo info,
int[] actual,
java.lang.Object[] other) |
Assert that the actual array has the same size as the other array.
|
void |
Iterables.assertHasSameSizeAs(AssertionInfo info,
java.lang.Iterable<?> actual,
java.lang.Iterable<?> other) |
Assert that the actual Iterable has the same size as the other Iterable.
|
void |
Iterables.assertHasSameSizeAs(AssertionInfo info,
java.lang.Iterable<?> actual,
java.lang.Object[] other) |
Assert that the actual Iterable has the same size as the other array.
|
void |
LongArrays.assertHasSameSizeAs(AssertionInfo info,
long[] actual,
java.lang.Iterable<?> other) |
Assert that the actual array has the same size as the other Iterable.
|
void |
LongArrays.assertHasSameSizeAs(AssertionInfo info,
long[] actual,
java.lang.Object[] other) |
Assert that the actual array has the same size as the other array.
|
void |
Maps.assertHasSameSizeAs(AssertionInfo info,
java.util.Map<?,?> map,
java.lang.Iterable<?> other) |
Asserts that the number of entries in the given Map has the same size as the other Iterable.
|
void |
Maps.assertHasSameSizeAs(AssertionInfo info,
java.util.Map<?,?> map,
java.lang.Object[] other) |
Asserts that the number of entries in the given Map has the same size as the other array.
|
void |
ObjectArrays.assertHasSameSizeAs(AssertionInfo info,
java.lang.Object[] actual,
java.lang.Iterable<?> other) |
Assert that the actual array has the same size as the other Iterable.
|
void |
ObjectArrays.assertHasSameSizeAs(AssertionInfo info,
java.lang.Object[] actual,
java.lang.Object[] other) |
Assert that the actual array has the same size as the other array.
|
void |
ShortArrays.assertHasSameSizeAs(AssertionInfo info,
short[] actual,
java.lang.Iterable<?> other) |
Assert that the actual array has the same size as the other Iterable.
|
void |
ShortArrays.assertHasSameSizeAs(AssertionInfo info,
short[] actual,
java.lang.Object[] other) |
Assert that the actual array has the same size as the other array.
|
void |
Strings.assertHasSameSizeAs(AssertionInfo info,
java.lang.String actual,
java.lang.Iterable<?> other) |
Asserts that the number of entries in the given String has the same size as the other Iterable.
|
void |
Strings.assertHasSameSizeAs(AssertionInfo info,
java.lang.String actual,
java.lang.Object[] other) |
Asserts that the number of entries in the given String 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,
java.lang.Iterable<?> actual,
int expectedSize) |
Asserts that the number of elements in the given Iterable is equal to the expected one.
|
void |
LongArrays.assertHasSize(AssertionInfo info,
long[] actual,
int expectedSize) |
Asserts that the number of elements in the given array is equal to the expected one.
|
void |
Maps.assertHasSize(AssertionInfo info,
java.util.Map<?,?> actual,
int expectedSize) |
Asserts that the number of entries in the given Map is equal to the expected one.
|
void |
ObjectArrays.assertHasSize(AssertionInfo info,
java.lang.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,
java.lang.String actual,
int expectedSize) |
Asserts that the size of the given String is equal to the expected one.
|
void |
Dates.assertHasTime(AssertionInfo info,
java.util.Date actual,
long timestamp) |
Verifies that the actual Date time is equal to the given timestamp.
|
<E> void |
Iterables.assertHave(AssertionInfo info,
java.lang.Iterable<? extends E> actual,
Condition<? super E> condition) |
Assert that each element of given Iterable satisfies the given condition.
|
<E> void |
ObjectArrays.assertHave(AssertionInfo info,
E[] actual,
Condition<? super E> condition) |
Assert that each element of given array satisfies the given condition.
|
<E> void |
Iterables.assertHaveAtLeast(AssertionInfo info,
java.lang.Iterable<? extends E> actual,
int times,
Condition<? super E> condition) |
|
<E> void |
ObjectArrays.assertHaveAtLeast(AssertionInfo info,
E[] actual,
int times,
Condition<? super E> condition) |
|
<E> void |
Iterables.assertHaveAtMost(AssertionInfo info,
java.lang.Iterable<? extends E> actual,
int times,
Condition<? super E> condition) |
|
<E> void |
ObjectArrays.assertHaveAtMost(AssertionInfo info,
E[] actual,
int times,
Condition<? super E> condition) |
|
<E> void |
Iterables.assertHaveExactly(AssertionInfo info,
java.lang.Iterable<? extends E> actual,
int times,
Condition<? super E> condition) |
|
<E> void |
ObjectArrays.assertHaveExactly(AssertionInfo info,
E[] actual,
int times,
Condition<? super E> condition) |
|
<T> void |
Conditions.assertIs(AssertionInfo info,
T actual,
Condition<? super T> condition) |
Asserts that the actual value satisfies the given Condition. |
<T> void |
Lists.assertIs(AssertionInfo info,
java.util.List<T> actual,
Condition<? super T> condition,
Index index) |
Verifies that the given List satisfies the given Condition at the given index. |
void |
Files.assertIsAbsolute(AssertionInfo info,
java.io.File actual) |
Asserts that the given file is an absolute path.
|
void |
Dates.assertIsAfter(AssertionInfo info,
java.util.Date actual,
java.util.Date other) |
Verifies that the actual Date is strictly after the given one.
|
void |
Dates.assertIsAfterOrEqualsTo(AssertionInfo info,
java.util.Date actual,
java.util.Date other) |
Verifies that the actual Date is after or equal to the given one.
|
void |
Dates.assertIsAfterYear(AssertionInfo info,
java.util.Date actual,
int year) |
Verifies that the actual Date is strictly after the given year.
|
void |
Dates.assertIsBefore(AssertionInfo info,
java.util.Date actual,
java.util.Date other) |
Verifies that the actual Date is strictly before the given one.
|
void |
Dates.assertIsBeforeOrEqualsTo(AssertionInfo info,
java.util.Date actual,
java.util.Date other) |
Verifies that the actual Date is before or equal to the given one.
|
void |
Dates.assertIsBeforeYear(AssertionInfo info,
java.util.Date actual,
int year) |
Verifies that the actual Date is strictly before the given year.
|
void |
Dates.assertIsBetween(AssertionInfo info,
java.util.Date actual,
java.util.Date start,
java.util.Date end,
boolean inclusiveStart,
boolean inclusiveEnd) |
Verifies that the actual Date is in start:end period.
start date belongs to the period if inclusiveStart is true.
end date belongs to the period if inclusiveEnd is true.
|
void |
Dates.assertIsCloseTo(AssertionInfo info,
java.util.Date actual,
java.util.Date other,
long deltaInMilliseconds) |
Verifies that the actual Date is close to the other date by less than delta, if difference is equals to delta it is
ok.
Note that delta expressed in milliseconds.
Use handy TimeUnit to convert a duration in milliseconds, for example you can express a delta of 5 seconds with
TimeUnit.SECONDS.toMillis(5).
|
void |
Files.assertIsDirectory(AssertionInfo info,
java.io.File actual) |
Asserts that the given file is an existing directory.
|
void |
Objects.assertIsExactlyInstanceOf(AssertionInfo info,
java.lang.Object actual,
java.lang.Class<?> type) |
Verifies that the actual value is exactly a instance of given type.
|
void |
Files.assertIsFile(AssertionInfo info,
java.io.File actual) |
Asserts that the given file is an existing file.
|
<A> void |
Objects.assertIsIn(AssertionInfo info,
A actual,
java.lang.Iterable<? extends A> values) |
Asserts that the given object is present in the given collection.
|
void |
Objects.assertIsIn(AssertionInfo info,
java.lang.Object actual,
java.lang.Object[] values) |
Asserts that the given object is present in the given array.
|
void |
Dates.assertIsInSameDayAs(AssertionInfo info,
java.util.Date actual,
java.util.Date other) |
Verifies that actual and given Date are chronologically in the same day of month (and thus in the same month and
year).
|
void |
Dates.assertIsInSameHourAs(AssertionInfo info,
java.util.Date actual,
java.util.Date other) |
Verifies that actual and given Date are chronologically in the same hour (and thus in the same day of month, month
and year).
|
void |
Dates.assertIsInSameMinuteAs(AssertionInfo info,
java.util.Date actual,
java.util.Date other) |
Verifies that actual and given Date are chronologically in the same minute (and thus in the same hour, day of month,
month and year).
|
void |
Dates.assertIsInSameMonthAs(AssertionInfo info,
java.util.Date actual,
java.util.Date other) |
Verifies that actual and given Date are chronologically in the same month (and thus in the same year).
|
void |
Dates.assertIsInSameSecondAs(AssertionInfo info,
java.util.Date actual,
java.util.Date other) |
Verifies that actual and given Date are chronologically in the same second (and thus in the same minute, hour, day of
month, month and year).
|
void |
Dates.assertIsInSameYearAs(AssertionInfo info,
java.util.Date actual,
java.util.Date other) |
Verifies that actual and given Date are in the same year.
|
void |
Objects.assertIsInstanceOf(AssertionInfo info,
java.lang.Object actual,
java.lang.Class<?> type) |
Verifies that the given object is an instance of the given type.
|
void |
Objects.assertIsInstanceOfAny(AssertionInfo info,
java.lang.Object actual,
java.lang.Class<?>[] types) |
Verifies that the given object is an instance of any of the given types.
|
void |
Dates.assertIsInTheFuture(AssertionInfo info,
java.util.Date actual) |
Verifies that the actual Date is strictly in the future.
|
void |
Dates.assertIsInThePast(AssertionInfo info,
java.util.Date actual) |
Verifies that the actual Date is strictly in the past.
|
<A> void |
Objects.assertIsLenientEqualsToByAcceptingFields(AssertionInfo info,
A actual,
A other,
java.lang.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,
java.lang.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 to NaN.
It does not rely on the custom comparisonStrategy (if one is set).
|
void |
Numbers.assertIsNegative(AssertionInfo info,
NUMBER actual) |
Asserts that the actual value is negative.
|
<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,
java.util.Date actual,
java.util.Date start,
java.util.Date end,
boolean inclusiveStart,
boolean inclusiveEnd) |
Verifies that the actual Date is not in start:end period..
start date belongs to the period if inclusiveStart is true.
end date belongs to the period if inclusiveEnd is true.
|
void |
Objects.assertIsNotExactlyInstanceOf(AssertionInfo info,
java.lang.Object actual,
java.lang.Class<?> type) |
Verifies that the actual value is not exactly a instance of given type.
|
<A> void |
Objects.assertIsNotIn(AssertionInfo info,
A actual,
java.lang.Iterable<? extends A> values) |
Asserts that the given object is not present in the given collection.
|
void |
Objects.assertIsNotIn(AssertionInfo info,
java.lang.Object actual,
java.lang.Object[] values) |
Asserts that the given object is not present in the given array.
|
void |
Objects.assertIsNotInstanceOf(AssertionInfo info,
java.lang.Object actual,
java.lang.Class<?> type) |
Verifies that the given object is not an instance of the given type.
|
void |
Objects.assertIsNotInstanceOfAny(AssertionInfo info,
java.lang.Object actual,
java.lang.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 to NaN.
|
void |
Numbers.assertIsNotNegative(AssertionInfo info,
NUMBER actual) |
Asserts that the actual value is not negative.
|
void |
Objects.assertIsNotOfAnyClassIn(AssertionInfo info,
java.lang.Object actual,
java.lang.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,
java.lang.Object actual,
java.lang.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,
java.io.File actual) |
Asserts that the given file is a relative path.
|
void |
BooleanArrays.assertIsSorted(AssertionInfo info,
boolean[] actual) |
|
void |
ByteArrays.assertIsSorted(AssertionInfo info,
byte[] actual) |
|
void |
CharArrays.assertIsSorted(AssertionInfo info,
char[] actual) |
|
void |
DoubleArrays.assertIsSorted(AssertionInfo info,
double[] actual) |
|
void |
FloatArrays.assertIsSorted(AssertionInfo info,
float[] actual) |
|
void |
IntArrays.assertIsSorted(AssertionInfo info,
int[] actual) |
|
void |
Lists.assertIsSorted(AssertionInfo info,
java.util.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) |
|
void |
ObjectArrays.assertIsSorted(AssertionInfo info,
java.lang.Object[] actual) |
|
void |
ShortArrays.assertIsSorted(AssertionInfo info,
short[] actual) |
|
void |
BooleanArrays.assertIsSortedAccordingToComparator(AssertionInfo info,
boolean[] actual,
java.util.Comparator<? super java.lang.Boolean> comparator) |
|
void |
ByteArrays.assertIsSortedAccordingToComparator(AssertionInfo info,
byte[] actual,
java.util.Comparator<? super java.lang.Byte> comparator) |
|
void |
CharArrays.assertIsSortedAccordingToComparator(AssertionInfo info,
char[] actual,
java.util.Comparator<? super java.lang.Character> comparator) |
|
void |
DoubleArrays.assertIsSortedAccordingToComparator(AssertionInfo info,
double[] actual,
java.util.Comparator<? super java.lang.Double> comparator) |
|
void |
FloatArrays.assertIsSortedAccordingToComparator(AssertionInfo info,
float[] actual,
java.util.Comparator<? super java.lang.Float> comparator) |
|
void |
IntArrays.assertIsSortedAccordingToComparator(AssertionInfo info,
int[] actual,
java.util.Comparator<? super java.lang.Integer> comparator) |
|
void |
Lists.assertIsSortedAccordingToComparator(AssertionInfo info,
java.util.List<?> actual,
java.util.Comparator<? extends java.lang.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,
java.util.Comparator<? super java.lang.Long> comparator) |
|
<E> void |
ObjectArrays.assertIsSortedAccordingToComparator(AssertionInfo info,
E[] actual,
java.util.Comparator<? super E> comparator) |
|
void |
ShortArrays.assertIsSortedAccordingToComparator(AssertionInfo info,
short[] actual,
java.util.Comparator<? super java.lang.Short> comparator) |
|
void |
Iterables.assertIsSubsetOf(AssertionInfo info,
java.lang.Iterable<?> actual,
java.lang.Iterable<?> values) |
Verifies that the actual Iterable is a subset of values Iterable.
|
void |
Dates.assertIsToday(AssertionInfo info,
java.util.Date actual) |
Verifies that the actual Date is today, by comparing only year, month and day of actual to today (ie.
|
void |
Dates.assertIsWithinDayOfMonth(AssertionInfo info,
java.util.Date actual,
int dayOfMonth) |
Verifies that the actual Date day of month is equal to the given day of month.
|
void |
Dates.assertIsWithinDayOfWeek(AssertionInfo info,
java.util.Date actual,
int dayOfWeek) |
Verifies that the actual Date day of week is equal to the given day of week.
|
void |
Dates.assertIsWithinHourOfDay(AssertionInfo info,
java.util.Date actual,
int hourOfDay) |
Verifies that the actual Date hour od day is equal to the given hour of day (24-hour clock).
|
void |
Dates.assertIsWithinMillisecond(AssertionInfo info,
java.util.Date actual,
int millisecond) |
Verifies that the actual Date millisecond is equal to the given millisecond.
|
void |
Dates.assertIsWithinMinute(AssertionInfo info,
java.util.Date actual,
int minute) |
Verifies that the actual Date minute is equal to the given minute.
|
void |
Dates.assertIsWithinMonth(AssertionInfo info,
java.util.Date actual,
int month) |
Verifies that the actual Date month is equal to the given month, month value starting at 1 (January=1,
February=2, ...).
|
void |
Dates.assertIsWithinSecond(AssertionInfo info,
java.util.Date actual,
int second) |
Verifies that the actual Date second is equal to the given second.
|
void |
Dates.assertIsWithinYear(AssertionInfo info,
java.util.Date actual,
int year) |
Verifies that the actual Date 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 java.lang.Comparable<? super T>>
void |
Comparables.assertLessThan(AssertionInfo info,
T actual,
T other) |
Asserts that the actual value is less than the other one.
|
<T extends java.lang.Comparable<? super T>>
void |
Comparables.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,
java.lang.Character actual) |
Asserts that the actual value is a lowercase character.
|
void |
Strings.assertMatches(AssertionInfo info,
java.lang.String actual,
java.lang.String regex) |
Verifies that the given String matches the given regular expression.
|
void |
Strings.assertMatches(AssertionInfo info,
java.lang.String actual,
java.util.regex.Pattern pattern) |
Verifies that the given String 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,
java.lang.Iterable<?> actual) |
Asserts that the given Iterable is not empty.
|
void |
LongArrays.assertNotEmpty(AssertionInfo info,
long[] actual) |
Asserts that the given array is not empty.
|
void |
Maps.assertNotEmpty(AssertionInfo info,
java.util.Map<?,?> actual) |
Asserts that the given Map is not empty.
|
void |
ObjectArrays.assertNotEmpty(AssertionInfo info,
java.lang.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,
java.lang.String actual) |
Asserts that the given String is not empty.
|
void |
Booleans.assertNotEqual(AssertionInfo info,
java.lang.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,
java.lang.Object actual,
java.lang.Object other) |
Asserts that two objects are not equal.
|
<T extends java.lang.Comparable<? super T>>
void |
Comparables.assertNotEqualByComparison(AssertionInfo info,
T actual,
T other) |
Asserts that two Comparables are not equal by invoking Comparable.compareTo(Object)
.
Note that it does not rely on the custom Comparables.comparisonStrategy if one has been set. |
protected static <T> void |
Comparables.assertNotNull(AssertionInfo info,
T actual) |
|
void |
Objects.assertNotNull(AssertionInfo info,
java.lang.Object actual) |
Asserts that the given object is not null.
|
void |
Objects.assertNotSame(AssertionInfo info,
java.lang.Object actual,
java.lang.Object other) |
Asserts that two objects do not refer to the same object.
|
void |
Objects.assertNull(AssertionInfo info,
java.lang.Object actual) |
Asserts that the given object is null.
|
void |
BooleanArrays.assertNullOrEmpty(AssertionInfo info,
boolean[] actual) |
Asserts that the given array is null or empty.
|
void |
ByteArrays.assertNullOrEmpty(AssertionInfo info,
byte[] actual) |
Asserts that the given array is null or empty.
|
void |
CharArrays.assertNullOrEmpty(AssertionInfo info,
char[] actual) |
Asserts that the given array is null or empty.
|
void |
DoubleArrays.assertNullOrEmpty(AssertionInfo info,
double[] actual) |
Asserts that the given array is null or empty.
|
void |
FloatArrays.assertNullOrEmpty(AssertionInfo info,
float[] actual) |
Asserts that the given array is null or empty.
|
void |
IntArrays.assertNullOrEmpty(AssertionInfo info,
int[] actual) |
Asserts that the given array is null or empty.
|
void |
Iterables.assertNullOrEmpty(AssertionInfo info,
java.lang.Iterable<?> actual) |
Asserts that the given Iterablenull or empty.
|
void |
LongArrays.assertNullOrEmpty(AssertionInfo info,
long[] actual) |
Asserts that the given array is null or empty.
|
void |
Maps.assertNullOrEmpty(AssertionInfo info,
java.util.Map<?,?> actual) |
Asserts that the given Map is null or empty.
|
void |
ObjectArrays.assertNullOrEmpty(AssertionInfo info,
java.lang.Object[] actual) |
Asserts that the given array is null or empty.
|
void |
ShortArrays.assertNullOrEmpty(AssertionInfo info,
short[] actual) |
Asserts that the given array is null or empty.
|
void |
Strings.assertNullOrEmpty(AssertionInfo info,
java.lang.String actual) |
Asserts that the given String is null or empty.
|
void |
Objects.assertSame(AssertionInfo info,
java.lang.Object actual,
java.lang.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,
java.lang.Iterable<?> actual,
java.lang.Object[] sequence) |
Verifies that the given Iterable starts with the given sequence of objects, without any other objects
between them.
|
void |
LongArrays.assertStartsWith(AssertionInfo info,
long[] actual,
long[] sequence) |
Verifies that the given array starts with the given sequence of values, without any other values between them.
|
void |
ObjectArrays.assertStartsWith(AssertionInfo info,
java.lang.Object[] actual,
java.lang.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,
java.lang.String actual,
java.lang.String prefix) |
Verifies that the given String starts with the given prefix.
|
void |
Characters.assertUpperCase(AssertionInfo info,
java.lang.Character actual) |
Asserts that the actual value is a uppercase character.
|
java.lang.AssertionError |
Failures.failure(AssertionInfo info,
AssertionErrorFactory factory) |
|
java.lang.AssertionError |
Failures.failure(AssertionInfo info,
ErrorMessageFactory message) |
Creates a AssertionError following this pattern:
creates a AssertionError using overridingErrorMessage() as the
error message if such value is not null, or
uses the given ErrorMessageFactory to create the detail message of the
AssertionError, prepending the value of description() to the error
message
|