Package | Description |
---|---|
org.assertj.core.api | |
org.assertj.core.error | |
org.assertj.core.internal |
Modifier and Type | Class and Description |
---|---|
class |
WritableAssertionInfo
Writable information about an assertion.
|
Modifier and Type | Method and Description |
---|---|
String |
ElementsShouldSatisfy.UnsatisfiedRequirement.describe(AssertionInfo info) |
static String |
ZippedElementsShouldSatisfy.ZipSatisfyError.describe(AssertionInfo info,
ZippedElementsShouldSatisfy.ZipSatisfyError satisfyError) |
static ErrorMessageFactory |
ElementsShouldSatisfy.elementsShouldSatisfy(Object actual,
List<ElementsShouldSatisfy.UnsatisfiedRequirement> elementsNotSatisfyingRestrictions,
AssertionInfo info) |
static ErrorMessageFactory |
ElementsShouldSatisfy.elementsShouldSatisfyAny(Object actual,
List<ElementsShouldSatisfy.UnsatisfiedRequirement> elementsNotSatisfyingRequirements,
AssertionInfo info) |
static ErrorMessageFactory |
ZippedElementsShouldSatisfy.zippedElementsShouldSatisfy(AssertionInfo info,
Iterable<?> actual,
Iterable<?> other,
List<ZippedElementsShouldSatisfy.ZipSatisfyError> zipSatisfyErrors) |
Modifier and Type | Method and Description |
---|---|
<E> void |
Iterables.assertAllMatch(AssertionInfo info,
Iterable<? extends E> actual,
Predicate<? super E> predicate,
PredicateDescription predicateDescription) |
<E> void |
Iterables.assertAllSatisfy(AssertionInfo info,
Iterable<? extends E> actual,
Consumer<? super E> requirements) |
<K,V> void |
Maps.assertAllSatisfy(AssertionInfo info,
Map<K,V> actual,
BiConsumer<? super K,? super V> entryRequirements) |
<E> void |
Iterables.assertAnyMatch(AssertionInfo info,
Iterable<? extends E> actual,
Predicate<? super E> predicate,
PredicateDescription predicateDescription) |
<E> void |
Iterables.assertAnySatisfy(AssertionInfo info,
Iterable<? extends E> actual,
Consumer<? super E> requirements) |
<K,V> void |
Maps.assertAnySatisfy(AssertionInfo info,
Map<K,V> actual,
BiConsumer<? super K,? super V> entryRequirements) |
<E> void |
ObjectArrays.assertAre(AssertionInfo info,
E[] actual,
Condition<? super E> condition)
Assert that each element of given array satisfies the given condition.
|
<E> void |
Arrays.assertAre(AssertionInfo info,
Failures failures,
Conditions conditions,
Object array,
Condition<E> condition) |
<T> void |
Iterables.assertAre(AssertionInfo info,
Iterable<? extends T> actual,
Condition<? super T> condition)
Assert that each element of given
Iterable satisfies the given condition. |
<E> void |
ObjectArrays.assertAreAtLeast(AssertionInfo info,
E[] actual,
int n,
Condition<? super E> condition)
Assert that there are at least n array elements satisfying the given condition.
|
<E> void |
Arrays.assertAreAtLeast(AssertionInfo info,
Failures failures,
Conditions conditions,
Object array,
int times,
Condition<E> condition) |
<E> void |
Iterables.assertAreAtLeast(AssertionInfo info,
Iterable<? extends E> actual,
int times,
Condition<? super E> condition)
Assert that there are at least n elements in the actual
Iterable satisfying the given
condition. |
<E> void |
ObjectArrays.assertAreAtMost(AssertionInfo info,
E[] actual,
int n,
Condition<? super E> condition)
Assert that there are at most n array elements satisfying the given condition.
|
<E> void |
Arrays.assertAreAtMost(AssertionInfo info,
Failures failures,
Conditions conditions,
Object array,
int times,
Condition<E> condition) |
<E> void |
Iterables.assertAreAtMost(AssertionInfo info,
Iterable<? extends E> actual,
int n,
Condition<? super E> condition)
Assert that there are at most n elements in the actual
Iterable satisfying the given
condition. |
<E> void |
ObjectArrays.assertAreExactly(AssertionInfo info,
E[] actual,
int n,
Condition<? super E> condition)
Verifies that there are exactly n array elements satisfying the given condition.
|
<E> void |
Arrays.assertAreExactly(AssertionInfo info,
Failures failures,
Conditions conditions,
Object array,
int times,
Condition<E> condition) |
<E> void |
Iterables.assertAreExactly(AssertionInfo info,
Iterable<? extends E> actual,
int times,
Condition<? super E> condition)
Verifies that there are exactly n elements in the actual
Iterable satisfying the given
condition. |
<E> void |
ObjectArrays.assertAreNot(AssertionInfo info,
E[] actual,
Condition<? super E> condition)
Assert that each element of given array not satisfies the given condition.
|
<E> void |
Arrays.assertAreNot(AssertionInfo info,
Failures failures,
Conditions conditions,
Object array,
Condition<E> condition) |
<E> void |
Iterables.assertAreNot(AssertionInfo info,
Iterable<? extends E> actual,
Condition<? super E> condition)
Assert that each element of given
Iterable not satisfies the given condition. |
void |
Strings.assertBlank(AssertionInfo info,
CharSequence actual)
Asserts that the given
CharSequence is Null , empty or consists of one or more whitespace characters. |
void |
Files.assertCanRead(AssertionInfo info,
File actual)
Asserts that the given file can be read by the application.
|
void |
Files.assertCanWrite(AssertionInfo info,
File actual)
Asserts that the given file can be modified by the application.
|
void |
BooleanArrays.assertContains(AssertionInfo info,
boolean[] actual,
boolean[] values)
Asserts that the given array contains the given values, in any order.
|
void |
BooleanArrays.assertContains(AssertionInfo info,
boolean[] actual,
boolean value,
Index index)
Verifies that the given array contains the given value at the given index.
|
void |
ByteArrays.assertContains(AssertionInfo info,
byte[] actual,
byte[] values)
Asserts that the given array contains the given values, in any order.
|
void |
ByteArrays.assertContains(AssertionInfo info,
byte[] actual,
byte value,
Index index)
Verifies that the given array contains the given value at the given index.
|
void |
ByteArrays.assertContains(AssertionInfo info,
byte[] actual,
int[] values)
Asserts that the given array contains the given values, in any order.
|
void |
ByteArrays.assertContains(AssertionInfo info,
byte[] actual,
int value,
Index index)
Verifies that the given array contains the given value at the given index.
|
void |
CharArrays.assertContains(AssertionInfo info,
char[] actual,
char[] values)
Asserts that the given array contains the given values, in any order.
|
void |
CharArrays.assertContains(AssertionInfo info,
char[] actual,
char value,
Index index)
Verifies that the given array contains the given value at the given index.
|
void |
Strings.assertContains(AssertionInfo info,
CharSequence actual,
CharSequence... values)
Verifies that the given
CharSequence contains the given strings. |
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 |
Arrays.assertContains(AssertionInfo info,
Failures failures,
Object actual,
Object values) |
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 given
Iterable contains the given values, in any order. |
void |
Lists.assertContains(AssertionInfo info,
List<?> actual,
Object value,
Index index)
Verifies that the given
List contains the given object at the given index. |
void |
LongArrays.assertContains(AssertionInfo info,
long[] actual,
long[] values)
Asserts that the given array contains the given values, in any order.
|
void |
LongArrays.assertContains(AssertionInfo info,
long[] actual,
long value,
Index index)
Verifies that the given array contains the given value at the given index.
|
<K,V> void |
Maps.assertContains(AssertionInfo info,
Map<K,V> actual,
Map.Entry<? extends K,? extends V>[] entries)
Asserts that the given
Map 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.
|
<E> void |
ObjectArrays.assertContainsAll(AssertionInfo info,
E[] actual,
Iterable<? extends E> other)
Asserts that the given array contains all the elements of the given
Iterable , in any order. |
void |
Iterables.assertContainsAll(AssertionInfo info,
Iterable<?> actual,
Iterable<?> other)
Asserts that the given
Iterable contains all the elements of the other Iterable , in any order. |
void |
Classes.assertContainsAnnotations(AssertionInfo info,
Class<?> actual,
Class<? extends Annotation>... annotations)
Verifies that the actual
Class contains the given Annotation s. |
void |
BooleanArrays.assertContainsAnyOf(AssertionInfo info,
boolean[] actual,
boolean[] values) |
void |
ByteArrays.assertContainsAnyOf(AssertionInfo info,
byte[] actual,
byte[] values) |
void |
CharArrays.assertContainsAnyOf(AssertionInfo info,
char[] actual,
char[] values) |
void |
DoubleArrays.assertContainsAnyOf(AssertionInfo info,
double[] actual,
double[] values) |
void |
Arrays.assertContainsAnyOf(AssertionInfo info,
Failures failures,
Object actual,
Object values) |
void |
FloatArrays.assertContainsAnyOf(AssertionInfo info,
float[] actual,
float[] values) |
void |
IntArrays.assertContainsAnyOf(AssertionInfo info,
int[] actual,
int[] values) |
void |
Iterables.assertContainsAnyOf(AssertionInfo info,
Iterable<?> actual,
Object[] values)
Asserts that the given
Iterable contains at least one of the given values . |
void |
LongArrays.assertContainsAnyOf(AssertionInfo info,
long[] actual,
long[] values) |
<K,V> void |
Maps.assertContainsAnyOf(AssertionInfo info,
Map<K,V> actual,
Map.Entry<? extends K,? extends V>[] entries) |
void |
ObjectArrays.assertContainsAnyOf(AssertionInfo info,
Object[] actual,
Object[] values) |
void |
ShortArrays.assertContainsAnyOf(AssertionInfo info,
short[] actual,
short[] values) |
void |
BooleanArrays.assertContainsExactly(AssertionInfo info,
boolean[] actual,
boolean[] values) |
void |
ByteArrays.assertContainsExactly(AssertionInfo info,
byte[] actual,
byte[] values) |
void |
ByteArrays.assertContainsExactly(AssertionInfo info,
byte[] actual,
int[] values) |
void |
CharArrays.assertContainsExactly(AssertionInfo info,
char[] actual,
char[] values) |
void |
DoubleArrays.assertContainsExactly(AssertionInfo info,
double[] actual,
double[] values) |
void |
FloatArrays.assertContainsExactly(AssertionInfo info,
float[] actual,
float[] values) |
void |
IntArrays.assertContainsExactly(AssertionInfo info,
int[] actual,
int[] values) |
void |
Iterables.assertContainsExactly(AssertionInfo info,
Iterable<?> actual,
Object[] values)
Asserts that the given
Iterable contains exactly the given values and nothing else, in order. |
void |
LongArrays.assertContainsExactly(AssertionInfo info,
long[] actual,
long[] values) |
<K,V> void |
Maps.assertContainsExactly(AssertionInfo info,
Map<K,V> actual,
Map.Entry<? extends K,? extends V>... entries)
Verifies that the actual map contains only the given entries and nothing else, in order.
This assertion should only be used with map that have a consistent iteration order (i.e. |
void |
ObjectArrays.assertContainsExactly(AssertionInfo info,
Object[] actual,
Object[] values) |
void |
ShortArrays.assertContainsExactly(AssertionInfo info,
short[] actual,
short[] values) |
void |
BooleanArrays.assertContainsExactlyInAnyOrder(AssertionInfo info,
boolean[] actual,
boolean[] values) |
void |
ByteArrays.assertContainsExactlyInAnyOrder(AssertionInfo info,
byte[] actual,
byte[] values) |
void |
ByteArrays.assertContainsExactlyInAnyOrder(AssertionInfo info,
byte[] actual,
int[] values) |
void |
CharArrays.assertContainsExactlyInAnyOrder(AssertionInfo info,
char[] actual,
char[] values) |
void |
DoubleArrays.assertContainsExactlyInAnyOrder(AssertionInfo info,
double[] actual,
double[] values) |
void |
FloatArrays.assertContainsExactlyInAnyOrder(AssertionInfo info,
float[] actual,
float[] values) |
void |
IntArrays.assertContainsExactlyInAnyOrder(AssertionInfo info,
int[] actual,
int[] values) |
void |
Iterables.assertContainsExactlyInAnyOrder(AssertionInfo info,
Iterable<?> actual,
Object[] values) |
void |
LongArrays.assertContainsExactlyInAnyOrder(AssertionInfo info,
long[] actual,
long[] values) |
void |
ObjectArrays.assertContainsExactlyInAnyOrder(AssertionInfo info,
Object[] actual,
Object[] values) |
void |
ShortArrays.assertContainsExactlyInAnyOrder(AssertionInfo info,
short[] actual,
short[] values) |
void |
Strings.assertContainsIgnoringCase(AssertionInfo info,
CharSequence actual,
CharSequence sequence)
Verifies that the given
CharSequence contains the given sequence, ignoring case considerations. |
<K,V> void |
Maps.assertContainsKeys(AssertionInfo info,
Map<K,V> actual,
K... keys)
Verifies that the actual map contain the given key.
|
void |
Iterables.assertContainsNull(AssertionInfo info,
Iterable<?> actual)
Asserts that the given
Iterable contains at least a null element. |
void |
ObjectArrays.assertContainsNull(AssertionInfo info,
Object[] actual)
Asserts that the given array contains at least a null element.
|
void |
BooleanArrays.assertContainsOnly(AssertionInfo info,
boolean[] actual,
boolean[] values)
Asserts that the given array contains only the given values and nothing else, in any order.
|
void |
ByteArrays.assertContainsOnly(AssertionInfo info,
byte[] actual,
byte[] values)
Asserts that the given array contains only the given values and nothing else, in any order.
|
void |
ByteArrays.assertContainsOnly(AssertionInfo info,
byte[] actual,
int[] values)
Asserts that the given array contains only the given values and nothing else, in any order.
|
void |
CharArrays.assertContainsOnly(AssertionInfo info,
char[] actual,
char[] values)
Asserts that the given array contains only the given values and nothing else, in any order.
|
void |
DoubleArrays.assertContainsOnly(AssertionInfo info,
double[] actual,
double[] values)
Asserts that the given array contains only the given values and nothing else, in any order.
|
void |
FloatArrays.assertContainsOnly(AssertionInfo info,
float[] actual,
float[] values)
Asserts that the given array contains only the given values and nothing else, in any order.
|
void |
IntArrays.assertContainsOnly(AssertionInfo info,
int[] actual,
int[] values)
Asserts that the given array contains only the given values and nothing else, in any order.
|
void |
Iterables.assertContainsOnly(AssertionInfo info,
Iterable<?> actual,
Object[] expectedValues)
Asserts that the given
Iterable contains only the given values and nothing else, in any order. |
void |
LongArrays.assertContainsOnly(AssertionInfo info,
long[] actual,
long[] values)
Asserts that the given array contains only the given values and nothing else, in any order.
|
<K,V> void |
Maps.assertContainsOnly(AssertionInfo info,
Map<K,V> actual,
Map.Entry<? extends K,? extends V>... entries)
Verifies that the actual map contains only the given entries and nothing else, in any order.
|
void |
ObjectArrays.assertContainsOnly(AssertionInfo info,
Object[] actual,
Object[] values)
Asserts that the given array contains only the given values and nothing else, in any order.
|
void |
ShortArrays.assertContainsOnly(AssertionInfo info,
short[] actual,
short[] values)
Asserts that the given array contains only the given values and nothing else, in any order.
|
void |
Strings.assertContainsOnlyDigits(AssertionInfo info,
CharSequence actual)
Verifies that the given
CharSequence contains only digits. |
<K,V> void |
Maps.assertContainsOnlyKeys(AssertionInfo info,
Map<K,V> actual,
Iterable<? extends K> keys)
Verifies that the actual map contains only the given keys and nothing else, in any order.
|
<K,V> void |
Maps.assertContainsOnlyKeys(AssertionInfo info,
Map<K,V> actual,
K... keys)
Verifies that the actual map contains only the given keys and nothing else, in any order.
|
<K,V> void |
Maps.assertContainsOnlyKeys(AssertionInfo info,
Map<K,V> actual,
String placeholderForErrorMessages,
K[] keys) |
void |
Iterables.assertContainsOnlyNulls(AssertionInfo info,
Iterable<?> actual)
Asserts that the given
Iterable contains only null elements and nothing else. |
void |
ObjectArrays.assertContainsOnlyNulls(AssertionInfo info,
Object[] actual)
Asserts that the given array contains only null elements.
|
void |
BooleanArrays.assertContainsOnlyOnce(AssertionInfo info,
boolean[] actual,
boolean[] values)
Asserts that the given array contains only once the given values.
|
void |
ByteArrays.assertContainsOnlyOnce(AssertionInfo info,
byte[] actual,
byte[] values)
Asserts that the given array contains only once the given values.
|
void |
ByteArrays.assertContainsOnlyOnce(AssertionInfo info,
byte[] actual,
int[] values)
Asserts that the given array contains only once the given values.
|
void |
CharArrays.assertContainsOnlyOnce(AssertionInfo info,
char[] actual,
char[] values)
Asserts that the given array contains only once the given values.
|
void |
Strings.assertContainsOnlyOnce(AssertionInfo info,
CharSequence actual,
CharSequence sequence)
Verifies that actual
CharSequence s contains only once the given sequence. |
void |
DoubleArrays.assertContainsOnlyOnce(AssertionInfo info,
double[] actual,
double[] values)
Asserts that the given array contains only once the given values.
|
void |
FloatArrays.assertContainsOnlyOnce(AssertionInfo info,
float[] actual,
float[] values)
Asserts that the given array contains only once the given values.
|
void |
IntArrays.assertContainsOnlyOnce(AssertionInfo info,
int[] actual,
int[] values)
Asserts that the given array contains only once the given values.
|
void |
Iterables.assertContainsOnlyOnce(AssertionInfo info,
Iterable<?> actual,
Object[] values)
Asserts that the given
Iterable contains the given values and only once. |
void |
LongArrays.assertContainsOnlyOnce(AssertionInfo info,
long[] actual,
long[] values)
Asserts that the given array contains only once the given values.
|
void |
ObjectArrays.assertContainsOnlyOnce(AssertionInfo info,
Object[] actual,
Object[] values)
Asserts that the given array contains only once the given values.
|
void |
ShortArrays.assertContainsOnlyOnce(AssertionInfo info,
short[] actual,
short[] values)
Asserts that the given array contains only once the given values.
|
void |
Strings.assertContainsOnlyWhitespaces(AssertionInfo info,
CharSequence actual)
Asserts that the given
CharSequence consists of one or more whitespace characters. |
void |
Strings.assertContainsPattern(AssertionInfo info,
CharSequence actual,
CharSequence regex)
Verifies that the given
CharSequence contains the given regular expression. |
void |
Strings.assertContainsPattern(AssertionInfo info,
CharSequence actual,
Pattern pattern)
Verifies that the given
CharSequence contains the given regular expression. |
void |
BooleanArrays.assertContainsSequence(AssertionInfo info,
boolean[] actual,
boolean[] sequence)
Verifies that the given array contains the given sequence of values, without any other values between them.
|
void |
ByteArrays.assertContainsSequence(AssertionInfo info,
byte[] actual,
byte[] sequence)
Verifies that the given array contains the given sequence of values, without any other values between them.
|
void |
ByteArrays.assertContainsSequence(AssertionInfo info,
byte[] actual,
int[] sequence)
Verifies that the given array contains the given sequence of values, without any other values between them.
|
void |
CharArrays.assertContainsSequence(AssertionInfo info,
char[] actual,
char[] sequence)
Verifies that the given array contains the given sequence of values, without any other values between them.
|
void |
Strings.assertContainsSequence(AssertionInfo info,
CharSequence actual,
CharSequence[] sequence)
Verifies that the given charSequence contains the given sequence of charSequence, without any other charSequences between them.
|
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. |
void |
LongArrays.assertContainsSequence(AssertionInfo info,
long[] actual,
long[] sequence)
Verifies that the given array contains the given sequence of values, without any other values between them.
|
void |
ObjectArrays.assertContainsSequence(AssertionInfo info,
Object[] actual,
Object[] sequence)
Verifies that the given array contains the given sequence of objects, without any other objects between them.
|
void |
ShortArrays.assertContainsSequence(AssertionInfo info,
short[] actual,
short[] sequence)
Verifies that the given array contains the given sequence of values, without any other values between them.
|
void |
BooleanArrays.assertContainsSubsequence(AssertionInfo info,
boolean[] actual,
boolean[] subsequence)
Verifies that the given array contains the given subsequence of values (possibly with other values between them).
|
void |
ByteArrays.assertContainsSubsequence(AssertionInfo info,
byte[] actual,
byte[] subsequence)
Verifies that the given array contains the given sequence of values (possibly with other values between them).
|
void |
ByteArrays.assertContainsSubsequence(AssertionInfo info,
byte[] actual,
int[] subsequence)
Verifies that the given array contains the given sequence of values (possibly with other values between them).
|
void |
CharArrays.assertContainsSubsequence(AssertionInfo info,
char[] actual,
char[] subsequence)
Verifies that the given array contains the given subsequence of values (possibly with other values between them).
|
void |
Strings.assertContainsSubsequence(AssertionInfo info,
CharSequence actual,
CharSequence[] subsequence)
Verifies that the actual
CharSequence contains all the given values in the given order
(possibly with other values between them). |
void |
DoubleArrays.assertContainsSubsequence(AssertionInfo info,
double[] actual,
double[] subsequence)
Verifies that the given array contains the given subsequence of values (possibly with other values between them).
|
void |
FloatArrays.assertContainsSubsequence(AssertionInfo info,
float[] actual,
float[] subsequence)
Verifies that the given array contains the given subsequence of values (possibly with other values between them).
|
void |
IntArrays.assertContainsSubsequence(AssertionInfo info,
int[] actual,
int[] subsequence)
Verifies that the given array contains the given subsequence of values (possibly with other values between them).
|
void |
Iterables.assertContainsSubsequence(AssertionInfo info,
Iterable<?> actual,
List<?> subsequence) |
void |
Iterables.assertContainsSubsequence(AssertionInfo info,
Iterable<?> actual,
Object[] subsequence)
Verifies that the given
contains the given subsequence of objects (possibly with
other values between them). |
void |
LongArrays.assertContainsSubsequence(AssertionInfo info,
long[] actual,
long[] subsequence)
Verifies that the given array contains the given subsequence of values (possibly with other values between them).
|
void |
ObjectArrays.assertContainsSubsequence(AssertionInfo info,
Object[] actual,
Object[] subsequence)
Verifies that the given array contains the given subsequence of objects (possibly with other values between them).
|
void |
ShortArrays.assertContainsSubsequence(AssertionInfo info,
short[] actual,
short[] subsequence)
Verifies that the given array contains the given subsequence of values (possibly with other values between them).
|
<K,V> void |
Maps.assertContainsValue(AssertionInfo info,
Map<K,V> actual,
V value)
Verifies that the actual map contain the given value.
|
<K,V> void |
Maps.assertContainsValues(AssertionInfo info,
Map<K,V> actual,
V... values)
Verifies that the actual map contain the given values.
|
void |
Strings.assertContainsWhitespaces(AssertionInfo info,
CharSequence actual)
Asserts that the given
CharSequence contains one or more whitespace characters. |
void |
BooleanArrays.assertDoesNotContain(AssertionInfo info,
boolean[] actual,
boolean[] values)
Asserts that the given array does not contain the given values.
|
void |
BooleanArrays.assertDoesNotContain(AssertionInfo info,
boolean[] actual,
boolean value,
Index index)
Verifies that the given array does not contain the given value at the given index.
|
void |
ByteArrays.assertDoesNotContain(AssertionInfo info,
byte[] actual,
byte[] values)
Asserts that the given array does not contain the given values.
|
void |
ByteArrays.assertDoesNotContain(AssertionInfo info,
byte[] actual,
byte value,
Index index)
Verifies that the given array does not contain the given value at the given index.
|
void |
ByteArrays.assertDoesNotContain(AssertionInfo info,
byte[] actual,
int[] values)
Asserts that the given array does not contain the given values.
|
void |
ByteArrays.assertDoesNotContain(AssertionInfo info,
byte[] actual,
int value,
Index index)
Verifies that the given array does not contain the given value at the given index.
|
void |
CharArrays.assertDoesNotContain(AssertionInfo info,
char[] actual,
char[] values)
Asserts that the given array does not contain the given values.
|
void |
CharArrays.assertDoesNotContain(AssertionInfo info,
char[] actual,
char value,
Index index)
Verifies that the given array does not contain the given value at the given index.
|
void |
Strings.assertDoesNotContain(AssertionInfo info,
CharSequence actual,
CharSequence... values)
Verifies that the given
CharSequence does not contain any one of the given values. |
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 given
Iterable does not contain the given values. |
void |
Lists.assertDoesNotContain(AssertionInfo info,
List<?> actual,
Object value,
Index index)
Verifies that the given
List does not contain the given object at the given index. |
void |
LongArrays.assertDoesNotContain(AssertionInfo info,
long[] actual,
long[] values)
Asserts that the given array does not contain the given values.
|
void |
LongArrays.assertDoesNotContain(AssertionInfo info,
long[] actual,
long value,
Index index)
Verifies that the given array does not contain the given value at the given index.
|
<K,V> void |
Maps.assertDoesNotContain(AssertionInfo info,
Map<K,V> actual,
Map.Entry<? extends K,? extends V>[] entries)
Asserts that the given
Map 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.
|
<T> void |
Iterables.assertDoesNotContainAnyElementsOf(AssertionInfo info,
Iterable<? extends T> actual,
Iterable<? extends T> iterable)
Asserts that the given
Iterable does not contain the given values. |
<T> void |
ObjectArrays.assertDoesNotContainAnyElementsOf(AssertionInfo info,
Object[] actual,
Iterable<? extends T> iterable) |
void |
Strings.assertDoesNotContainAnyWhitespaces(AssertionInfo info,
CharSequence actual)
Asserts that the given
CharSequence is Null , empty or contains only non-whitespace characters. |
<K,V> void |
Maps.assertDoesNotContainKey(AssertionInfo info,
Map<K,V> actual,
K key)
Verifies that the actual map not contains the given key.
|
<K,V> void |
Maps.assertDoesNotContainKeys(AssertionInfo info,
Map<K,V> actual,
K... keys)
Verifies that the actual map not contains all the given keys.
|
void |
Iterables.assertDoesNotContainNull(AssertionInfo info,
Iterable<?> actual)
Asserts that the given
Iterable does not contain null elements. |
void |
ObjectArrays.assertDoesNotContainNull(AssertionInfo info,
Object[] actual)
Asserts that the given array does not contain null elements.
|
void |
Strings.assertDoesNotContainOnlyWhitespaces(AssertionInfo info,
CharSequence actual)
Asserts that the given
CharSequence is Null , empty or contains at least one non-whitespace character. |
void |
Strings.assertDoesNotContainPattern(AssertionInfo info,
CharSequence actual,
CharSequence regex)
Verifies that the given
CharSequence does not contain the given regular expression. |
void |
Strings.assertDoesNotContainPattern(AssertionInfo info,
CharSequence actual,
Pattern pattern)
Verifies that the given
CharSequence does not contain the given regular expression. |
void |
Iterables.assertDoesNotContainSequence(AssertionInfo info,
Iterable<?> actual,
Object[] sequence)
Verifies that the given
does not contain the given sequence of objects in order. |
void |
ObjectArrays.assertDoesNotContainSequence(AssertionInfo info,
Object[] actual,
Object[] sequence)
Verifies that the given array does not contain the given sequence of objects in order.
|
void |
Iterables.assertDoesNotContainSubsequence(AssertionInfo info,
Iterable<?> actual,
Object[] subsequence)
Verifies that the given
does not contain the given subsequence of objects (possibly
with other values between them). |
void |
ObjectArrays.assertDoesNotContainSubsequence(AssertionInfo info,
Object[] actual,
Object[] subsequence)
Verifies that the given array does not contain the given subsequence of objects (possibly with other values between
them).
|
<K,V> void |
Maps.assertDoesNotContainValue(AssertionInfo info,
Map<K,V> actual,
V value)
Verifies that the actual map not contains the given value.
|
void |
Strings.assertDoesNotEndWith(AssertionInfo info,
CharSequence actual,
CharSequence suffix)
Verifies that the given
CharSequence does not end with the given suffix. |
void |
Files.assertDoesNotExist(AssertionInfo info,
File actual)
Asserts that the given file does not exist.
|
void |
Paths.assertDoesNotExist(AssertionInfo info,
Path actual) |
<T> void |
Conditions.assertDoesNotHave(AssertionInfo info,
T actual,
Condition<? super T> condition)
Asserts that the actual value does not satisfy the given
. |
<E> void |
ObjectArrays.assertDoesNotHaveAnyElementsOfTypes(AssertionInfo info,
E[] actual,
Class<?>... unexpectedTypes) |
void |
BooleanArrays.assertDoesNotHaveDuplicates(AssertionInfo info,
boolean[] actual)
Asserts that the given array does not have duplicate values.
|
void |
ByteArrays.assertDoesNotHaveDuplicates(AssertionInfo info,
byte[] actual)
Asserts that the given array does not have duplicate values.
|
void |
CharArrays.assertDoesNotHaveDuplicates(AssertionInfo info,
char[] actual)
Asserts that the given array does not have duplicate values.
|
void |
DoubleArrays.assertDoesNotHaveDuplicates(AssertionInfo info,
double[] actual)
Asserts that the given array does not have duplicate values.
|
void |
FloatArrays.assertDoesNotHaveDuplicates(AssertionInfo info,
float[] actual)
Asserts that the given array does not have duplicate values.
|
void |
IntArrays.assertDoesNotHaveDuplicates(AssertionInfo info,
int[] actual)
Asserts that the given array does not have duplicate values.
|
void |
Iterables.assertDoesNotHaveDuplicates(AssertionInfo info,
Iterable<?> actual)
Asserts that the given
Iterable does not have duplicate values. |
void |
LongArrays.assertDoesNotHaveDuplicates(AssertionInfo info,
long[] actual)
Asserts that the given array does not have duplicate values.
|
void |
ObjectArrays.assertDoesNotHaveDuplicates(AssertionInfo info,
Object[] actual)
Asserts that the given array does not have duplicate values.
|
void |
ShortArrays.assertDoesNotHaveDuplicates(AssertionInfo info,
short[] actual)
Asserts that the given array does not have duplicate values.
|
void |
Objects.assertDoesNotHaveSameClassAs(AssertionInfo info,
Object actual,
Object other)
Verifies that the actual value does not have the same class as the given object.
|
void |
Strings.assertDoesNotMatch(AssertionInfo info,
CharSequence actual,
CharSequence regex)
Verifies that the given
CharSequence does not match the given regular expression. |
void |
Strings.assertDoesNotMatch(AssertionInfo info,
CharSequence actual,
Pattern pattern)
Verifies that the given
CharSequence does not match the given regular expression. |
void |
Strings.assertDoesNotStartWith(AssertionInfo info,
CharSequence actual,
CharSequence prefix)
Verifies that the given
CharSequence does not start with the given prefix. |
<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.assertDoNotHave(AssertionInfo info,
Iterable<? extends E> actual,
Condition<? super E> condition)
Assert that each element of given
Iterable not satisfies the given 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 |
Strings.assertEmpty(AssertionInfo info,
CharSequence actual)
Asserts that the given
CharSequence 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 given
Iterable 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 given
Map 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 |
BooleanArrays.assertEndsWith(AssertionInfo info,
boolean[] actual,
boolean[] sequence)
Verifies that the given array ends with the given sequence of values, without any other values between them.
|
void |
ByteArrays.assertEndsWith(AssertionInfo info,
byte[] actual,
byte[] sequence)
Verifies that the given array ends with the given sequence of values, without any other values between them.
|
void |
ByteArrays.assertEndsWith(AssertionInfo info,
byte[] actual,
int[] sequence)
Verifies that the given array ends with the given sequence of values, without any other values between them.
|
void |
CharArrays.assertEndsWith(AssertionInfo info,
char[] actual,
char[] sequence)
Verifies that the given array ends with the given sequence of values, without any other values between them.
|
void |
Strings.assertEndsWith(AssertionInfo info,
CharSequence actual,
CharSequence suffix)
Verifies that the given
CharSequence ends with the given suffix. |
void |
DoubleArrays.assertEndsWith(AssertionInfo info,
double[] actual,
double[] sequence)
Verifies that the given array ends with the given sequence of values, without any other values between them.
|
void |
FloatArrays.assertEndsWith(AssertionInfo info,
float[] actual,
float[] sequence)
Verifies that the given array ends with the given sequence of values, without any other values between them.
|
void |
IntArrays.assertEndsWith(AssertionInfo info,
int[] actual,
int[] sequence)
Verifies that the given array ends with the given sequence of values, without any other values between them.
|
void |
Iterables.assertEndsWith(AssertionInfo info,
Iterable<?> actual,
Object[] sequence)
Verifies that the given
Iterable ends with the given sequence of objects, without any other objects between
them. |
void |
Iterables.assertEndsWith(AssertionInfo info,
Iterable<?> actual,
Object first,
Object[] rest)
Verifies that the given
Iterable ends with the given sequence of objects, without any other objects between
them. |
void |
LongArrays.assertEndsWith(AssertionInfo info,
long[] actual,
long[] sequence)
Verifies that the given array ends with the given sequence of values, without any other values between them.
|
void |
ObjectArrays.assertEndsWith(AssertionInfo info,
Object[] actual,
Object[] sequence)
Verifies that the given array ends with the given sequence of objects, without any other objects between them.
|
void |
ObjectArrays.assertEndsWith(AssertionInfo info,
Object[] actual,
Object first,
Object[] rest)
Verifies that the given array ends with the given sequence of objects, without any other objects between them.
|
void |
Paths.assertEndsWith(AssertionInfo info,
Path actual,
Path end) |
void |
ShortArrays.assertEndsWith(AssertionInfo info,
short[] actual,
short[] sequence)
Verifies that the given array ends with the given sequence of values, without any other values between them.
|
void |
Paths.assertEndsWithRaw(AssertionInfo info,
Path actual,
Path end) |
void |
Booleans.assertEqual(AssertionInfo info,
Boolean actual,
boolean expected)
Asserts that two booleans are equal.
|
void |
Objects.assertEqual(AssertionInfo info,
Object actual,
Object expected)
Asserts that two objects are equal.
|
<T> void |
Comparables.assertEqual(AssertionInfo info,
T actual,
T expected)
Asserts that two T instances are equal.
|
<T extends Comparable<? super T>> |
Comparables.assertEqualByComparison(AssertionInfo info,
T actual,
T expected)
Asserts that two
s are equal by invoking
.Note that it does not rely on the custom Comparables.comparisonStrategy if one has been set. |
void |
Strings.assertEqualsIgnoringCase(AssertionInfo info,
CharSequence actual,
CharSequence expected)
Verifies that two
CharSequence s are equal, ignoring case considerations. |
void |
Strings.assertEqualsIgnoringWhitespace(AssertionInfo info,
CharSequence actual,
CharSequence expected)
Verifies that two
CharSequence s are equal, ignoring any differences in whitespace. |
void |
Strings.assertEqualsNormalizingWhitespace(AssertionInfo info,
CharSequence actual,
CharSequence expected)
Verifies that two
CharSequence s are equal, after the whitespace of both strings
has been normalized. |
void |
Files.assertExists(AssertionInfo info,
File actual)
Asserts that the given file exists, regardless it's a file or directory.
|
void |
Paths.assertExists(AssertionInfo info,
Path actual) |
void |
Paths.assertExistsNoFollowLinks(AssertionInfo info,
Path actual) |
<T extends Comparable<? super T>> |
Comparables.assertGreaterThan(AssertionInfo info,
T actual,
T other)
Asserts that the actual value is greater than the other one.
|
<T extends Comparable<? super T>> |
Comparables.assertGreaterThanOrEqualTo(AssertionInfo info,
T actual,
T other)
Asserts that the actual value is greater than or equal to the other one.
|
<T> void |
Lists.assertHas(AssertionInfo info,
List<? extends T> actual,
Condition<? super T> condition,
Index index)
Verifies that the given
List satisfies the given at the given index. |
<T> void |
Conditions.assertHas(AssertionInfo info,
T actual,
Condition<? super T> condition)
Asserts that the actual value satisfies the given
. |
<A> void |
Objects.assertHasAllNullFieldsOrPropertiesExcept(AssertionInfo info,
A actual,
String... propertiesOrFieldsToIgnore)
Asserts that the given object has null fields except the given ones.
|
void |
Urls.assertHasAnchor(AssertionInfo info,
URL actual,
String expected) |
<E> void |
ObjectArrays.assertHasAtLeastOneElementOfType(AssertionInfo info,
E[] actual,
Class<?> type) |
void |
Uris.assertHasAuthority(AssertionInfo info,
URI actual,
String expected) |
void |
Urls.assertHasAuthority(AssertionInfo info,
URL actual,
String expected) |
void |
Files.assertHasBinaryContent(AssertionInfo info,
File actual,
byte[] expected)
Asserts that the given file has the given binary content.
|
void |
Paths.assertHasBinaryContent(AssertionInfo info,
Path actual,
byte[] expected) |
void |
Throwables.assertHasCause(AssertionInfo info,
Throwable actual,
Throwable expectedCause) |
void |
Throwables.assertHasCauseExactlyInstanceOf(AssertionInfo info,
Throwable actual,
Class<? extends Throwable> type)
Assert that the cause of actual
Throwable is exactly an instance of the given type. |
void |
Throwables.assertHasCauseInstanceOf(AssertionInfo info,
Throwable actual,
Class<? extends Throwable> type)
Assert that the cause of actual
Throwable is an instance of the given type. |
void |
Files.assertHasContent(AssertionInfo info,
File actual,
String expected,
Charset charset)
Asserts that the given file has the given text content.
|
void |
InputStreams.assertHasContent(AssertionInfo info,
InputStream actual,
String expected)
Asserts that the given InputStream has the same content as the given String.
|
void |
Paths.assertHasContent(AssertionInfo info,
Path actual,
String expected,
Charset charset) |
void |
Dates.assertHasDayOfMonth(AssertionInfo info,
Date actual,
int dayOfMonth)
Verifies that the actual
Date day of month is equal to the given day of month. |
void |
Dates.assertHasDayOfWeek(AssertionInfo info,
Date actual,
int dayOfWeek)
Verifies that the actual
Date day of week is equal to the given day of week. |
void |
Classes.assertHasDeclaredFields(AssertionInfo info,
Class<?> actual,
String... fields)
Verifies that the actual
Class has the declared fields . |
void |
Classes.assertHasDeclaredMethods(AssertionInfo info,
Class<?> actual,
String... methods)
Verifies that the actual
Class has the declared methods . |
void |
Files.assertHasDigest(AssertionInfo info,
File actual,
MessageDigest digest,
byte[] expected) |
void |
Files.assertHasDigest(AssertionInfo info,
File actual,
MessageDigest digest,
String expected) |
void |
Files.assertHasDigest(AssertionInfo info,
File actual,
String algorithm,
byte[] expected) |
void |
Files.assertHasDigest(AssertionInfo info,
File actual,
String algorithm,
String expected) |
void |
InputStreams.assertHasDigest(AssertionInfo info,
InputStream actual,
MessageDigest digest,
byte[] expected) |
void |
InputStreams.assertHasDigest(AssertionInfo info,
InputStream actual,
MessageDigest digest,
String expected) |
void |
InputStreams.assertHasDigest(AssertionInfo info,
InputStream actual,
String algorithm,
byte[] expected) |
void |
InputStreams.assertHasDigest(AssertionInfo info,
InputStream actual,
String algorithm,
String expected) |
void |
Paths.assertHasDigest(AssertionInfo info,
Path actual,
MessageDigest digest,
byte[] expected) |
void |
Paths.assertHasDigest(AssertionInfo info,
Path actual,
MessageDigest digest,
String expected) |
void |
Paths.assertHasDigest(AssertionInfo info,
Path actual,
String algorithm,
byte[] expected) |
void |
Paths.assertHasDigest(AssertionInfo info,
Path actual,
String algorithm,
String expected) |
<K,V> void |
Maps.assertHasEntrySatisfying(AssertionInfo info,
Map<K,V> actual,
Condition<? super Map.Entry<K,V>> entryCondition)
Verifies that the given
Map contains an entry satisfying given entryCondition . |
<K,V> void |
Maps.assertHasEntrySatisfying(AssertionInfo info,
Map<K,V> actual,
K key,
Condition<? super V> valueCondition)
Verifies that the given
Map contains the value for given key that satisfy given valueCondition . |
<K,V> void |
Maps.assertHasEntrySatisfying(AssertionInfo info,
Map<K,V> actual,
K key,
Consumer<? super V> valueRequirements)
Verifies that the
Map contains the value for given key that satisfy given valueRequirements . |
<K,V> void |
Maps.assertHasEntrySatisfyingConditions(AssertionInfo info,
Map<K,V> actual,
Condition<? super K> keyCondition,
Condition<? super V> valueCondition)
Verifies that the given
Map contains an entry with key satisfying keyCondition
and value satisfying valueCondition . |
void |
Files.assertHasExtension(AssertionInfo info,
File actual,
String expected)
Asserts that the given
File has the given extension. |
<A> void |
Objects.assertHasFieldOrProperty(AssertionInfo info,
A actual,
String name) |
<A> void |
Objects.assertHasFieldOrPropertyWithValue(AssertionInfo info,
A actual,
String name,
Object expectedValue) |
void |
Paths.assertHasFileName(AssertionInfo info,
Path actual,
String fileName) |
void |
Uris.assertHasFragment(AssertionInfo info,
URI actual,
String expected) |
void |
Uris.assertHasHost(AssertionInfo info,
URI actual,
String expected) |
void |
Urls.assertHasHost(AssertionInfo info,
URL actual,
String expected) |
void |
Dates.assertHasHourOfDay(AssertionInfo info,
Date actual,
int hourOfDay)
Verifies that the actual
Date hour od day is equal to the given hour of day (24-hour clock). |
<K> void |
Maps.assertHasKeySatisfying(AssertionInfo info,
Map<K,?> actual,
Condition<? super K> keyCondition)
Verifies that the given
Map contains an entry with key satisfying keyCondition . |
void |
Strings.assertHasLineCount(AssertionInfo info,
CharSequence actual,
int expectedLineCount)
Asserts that the line count of the given
CharSequence is equal to the expected one. |
void |
Throwables.assertHasMessage(AssertionInfo info,
Throwable actual,
String expectedMessage)
Asserts that the given actual
Throwable message is equal to the given one. |
void |
Throwables.assertHasMessageContaining(AssertionInfo info,
Throwable actual,
String description)
Asserts that the message of the actual
Throwable contains with the given description. |
void |
Throwables.assertHasMessageEndingWith(AssertionInfo info,
Throwable actual,
String description)
Asserts that the message of the actual
Throwable ends with the given description. |
void |
Throwables.assertHasMessageFindingMatch(AssertionInfo info,
Throwable actual,
String regex)
Asserts that a sequence of the message of the actual
Throwable matches with the given regular expression (see Matcher.find() ). |
void |
Throwables.assertHasMessageMatching(AssertionInfo info,
Throwable actual,
String regex)
Asserts that the message of the actual
Throwable matches with the given regular expression. |
void |
Throwables.assertHasMessageNotContaining(AssertionInfo info,
Throwable actual,
String content) |
void |
Throwables.assertHasMessageStartingWith(AssertionInfo info,
Throwable actual,
String description)
Asserts that the message of the actual
Throwable starts with the given description. |
void |
Classes.assertHasMethods(AssertionInfo info,
Class<?> actual,
String... methods)
Verifies that the actual
Class has the methods . |
void |
Dates.assertHasMillisecond(AssertionInfo info,
Date actual,
int millisecond)
Verifies that the actual
Date millisecond is equal to the given millisecond. |
void |
Dates.assertHasMinute(AssertionInfo info,
Date actual,
int minute)
Verifies that the actual
Date minute is equal to the given minute. |
void |
Dates.assertHasMonth(AssertionInfo info,
Date actual,
int month)
Verifies that the actual
Date month is equal to the given month, month value starting at 1 (January=1,
February=2, ...). |
void |
Files.assertHasName(AssertionInfo info,
File actual,
String expected)
Asserts that the given
File has the given name. |
void |
Iterators.assertHasNext(AssertionInfo info,
Iterator<?> actual) |
void |
Throwables.assertHasNoCause(AssertionInfo info,
Throwable actual)
Asserts that the actual
Throwable does not have a cause. |
<A> void |
Objects.assertHasNoNullFieldsOrPropertiesExcept(AssertionInfo info,
A actual,
String... propertiesOrFieldsToIgnore)
Assert that the given object has no null fields except the given ones.
|
void |
Uris.assertHasNoParameter(AssertionInfo info,
URI actual,
String name) |
void |
Uris.assertHasNoParameter(AssertionInfo info,
URI actual,
String name,
String unwantedValue) |
void |
Urls.assertHasNoParameter(AssertionInfo info,
URL actual,
String name) |
void |
Urls.assertHasNoParameter(AssertionInfo info,
URL actual,
String name,
String unwantedValue) |
void |
Uris.assertHasNoParameters(AssertionInfo info,
URI actual) |
void |
Urls.assertHasNoParameters(AssertionInfo info,
URL actual) |
void |
Files.assertHasNoParent(AssertionInfo info,
File actual)
Asserts that the given
File does not have a parent. |
void |
Paths.assertHasNoParent(AssertionInfo info,
Path actual) |
void |
Paths.assertHasNoParentRaw(AssertionInfo info,
Path actual) |
void |
Throwables.assertHasNoSuppressedExceptions(AssertionInfo info,
Throwable actual) |
void |
Classes.assertHasOnlyDeclaredFields(AssertionInfo info,
Class<?> actual,
String... expectedFields)
Verifies that the actual
Class has the exactly the fields and nothing more. |
<E> void |
ObjectArrays.assertHasOnlyElementsOfType(AssertionInfo info,
E[] actual,
Class<?> type) |
<E> void |
ObjectArrays.assertHasOnlyElementsOfTypes(AssertionInfo info,
E[] actual,
Class<?>... types) |
<T> void |
Iterables.assertHasOnlyOneElementSatisfying(AssertionInfo info,
Iterable<? extends T> actual,
Consumer<? super T> consumer)
|
void |
Classes.assertHasOnlyPublicFields(AssertionInfo info,
Class<?> actual,
String... expectedFields)
Verifies that the actual
Class has only the fields and nothing more. |
void |
Uris.assertHasParameter(AssertionInfo info,
URI actual,
String name) |
void |
Uris.assertHasParameter(AssertionInfo info,
URI actual,
String expectedParameterName,
String expectedParameterValue) |
void |
Urls.assertHasParameter(AssertionInfo info,
URL actual,
String name) |
void |
Urls.assertHasParameter(AssertionInfo info,
URL actual,
String expectedParameterName,
String expectedParameterValue) |
void |
Files.assertHasParent(AssertionInfo info,
File actual,
File expected)
Asserts that the given
File has the given parent. |
void |
Paths.assertHasParent(AssertionInfo info,
Path actual,
Path expected) |
void |
Paths.assertHasParentRaw(AssertionInfo info,
Path actual,
Path expected) |
void |
Uris.assertHasPath(AssertionInfo info,
URI actual,
String path) |
void |
Urls.assertHasPath(AssertionInfo info,
URL actual,
String path) |
void |
Uris.assertHasPort(AssertionInfo info,
URI actual,
Integer expected) |
void |
Urls.assertHasPort(AssertionInfo info,
URL actual,
int expected) |
void |
Urls.assertHasProtocol(AssertionInfo info,
URL actual,
String protocol) |
void |
Classes.assertHasPublicFields(AssertionInfo info,
Class<?> actual,
String... fields)
Verifies that the actual
Class has the fields . |
void |
Classes.assertHasPublicMethods(AssertionInfo info,
Class<?> actual,
String... methods)
Verifies that the actual
Class has the public methods . |
void |
Uris.assertHasQuery(AssertionInfo info,
URI actual,
String expected) |
void |
Urls.assertHasQuery(AssertionInfo info,
URL actual,
String expected) |
void |
Throwables.assertHasRootCause(AssertionInfo info,
Throwable actual,
Throwable expectedRootCause)
Asserts that the actual
Throwable has a root cause similar to the given one. |
void |
Throwables.assertHasRootCauseExactlyInstanceOf(AssertionInfo info,
Throwable actual,
Class<? extends Throwable> type)
Assert that the root cause of actual
Throwable is exactly an instance of the given type. |
void |
Throwables.assertHasRootCauseInstanceOf(AssertionInfo info,
Throwable actual,
Class<? extends Throwable> type)
Assert that the root cause of actual
Throwable is an instance of the given type. |
void |
Objects.assertHasSameClassAs(AssertionInfo info,
Object actual,
Object other)
Verifies that the actual value has the same class as the given object.
|
void |
Paths.assertHasSameContentAs(AssertionInfo info,
Path actual,
Charset actualCharset,
Path expected,
Charset expectedCharset) |
<A> void |
Objects.assertHasSameHashCodeAs(AssertionInfo info,
A actual,
Object other)
Asserts that the actual object has the same hashCode as the given object.
|
void |
BooleanArrays.assertHasSameSizeAs(AssertionInfo info,
boolean[] actual,
Iterable<?> other)
Assert that the actual array has the same size as the other
Iterable . |
void |
BooleanArrays.assertHasSameSizeAs(AssertionInfo info,
boolean[] actual,
Object[] other)
Assert that the actual array has the same size as the other array.
|
void |
ByteArrays.assertHasSameSizeAs(AssertionInfo info,
byte[] actual,
Iterable<?> other)
Assert that the actual array has the same size as the other
Iterable . |
void |
CharArrays.assertHasSameSizeAs(AssertionInfo info,
char[] actual,
Iterable<?> other)
Assert that the actual array has the same size as the other
Iterable . |
void |
CharArrays.assertHasSameSizeAs(AssertionInfo info,
char[] actual,
Object[] other)
Assert that the actual array has the same size as the other array.
|
void |
Strings.assertHasSameSizeAs(AssertionInfo info,
CharSequence actual,
CharSequence other) |
void |
Strings.assertHasSameSizeAs(AssertionInfo info,
CharSequence actual,
Iterable<?> other)
Asserts that the number of entries in the given
CharSequence has the same size as the other
Iterable . |
void |
Strings.assertHasSameSizeAs(AssertionInfo info,
CharSequence actual,
Object array)
Asserts that the number of entries in the given
CharSequence has the same size as the other array. |
void |
DoubleArrays.assertHasSameSizeAs(AssertionInfo info,
double[] actual,
Iterable<?> other)
Assert that the actual array has the same size as the other
Iterable . |
void |
DoubleArrays.assertHasSameSizeAs(AssertionInfo info,
double[] actual,
Object[] other)
Assert that the actual array has the same size as the other array.
|
void |
FloatArrays.assertHasSameSizeAs(AssertionInfo info,
float[] actual,
Iterable<?> other)
Assert that the actual array has the same size as the other
Iterable . |
void |
FloatArrays.assertHasSameSizeAs(AssertionInfo info,
float[] actual,
Object[] other)
Assert that the actual array has the same size as the other array.
|
void |
IntArrays.assertHasSameSizeAs(AssertionInfo info,
int[] actual,
Iterable<?> other)
Assert that the actual array has the same size as the other
Iterable . |
void |
IntArrays.assertHasSameSizeAs(AssertionInfo info,
int[] actual,
Object[] other)
Assert that the actual array has the same size as the other array.
|
void |
Iterables.assertHasSameSizeAs(AssertionInfo info,
Iterable<?> actual,
Iterable<?> other)
Assert that the actual
Iterable has the same size as the other Iterable . |
void |
Iterables.assertHasSameSizeAs(AssertionInfo info,
Iterable<?> actual,
Object other)
Assert that the actual
Iterable has the same size as the other array. |
void |
LongArrays.assertHasSameSizeAs(AssertionInfo info,
long[] actual,
Iterable<?> other)
Assert that the actual array has the same size as the other
Iterable . |
void |
LongArrays.assertHasSameSizeAs(AssertionInfo info,
long[] actual,
Object[] other)
Assert that the actual array has the same size as the other array.
|
void |
Maps.assertHasSameSizeAs(AssertionInfo info,
Map<?,?> map,
Iterable<?> other)
Asserts that the number of entries in the given
Map has the same size as the other Iterable . |
void |
Maps.assertHasSameSizeAs(AssertionInfo info,
Map<?,?> map,
Map<?,?> other)
Asserts that the size of the given
Map is equal to the size of the other Map . |
void |
Maps.assertHasSameSizeAs(AssertionInfo info,
Map<?,?> map,
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,
Object[] actual,
Iterable<?> other)
Assert that the actual array has the same size as the other
Iterable . |
void |
ObjectArrays.assertHasSameSizeAs(AssertionInfo info,
Object[] actual,
Object other)
Assert that the actual array has the same size as the other array.
|
void |
Arrays.assertHasSameSizeAs(AssertionInfo info,
Object array,
Object other) |
void |
ShortArrays.assertHasSameSizeAs(AssertionInfo info,
short[] actual,
Iterable<?> other)
Assert that the actual array has the same size as the other
Iterable . |
void |
ShortArrays.assertHasSameSizeAs(AssertionInfo info,
short[] actual,
Object[] other)
Assert that the actual array has the same size as the other array.
|
void |
Dates.assertHasSameTime(AssertionInfo info,
Date actual,
Date expected)
Verifies that the actual
Date has same time as the given Date . |
void |
Uris.assertHasScheme(AssertionInfo info,
URI actual,
String scheme) |
void |
Dates.assertHasSecond(AssertionInfo info,
Date actual,
int second)
Verifies that the actual
Date second is equal to the given second. |
void |
BooleanArrays.assertHasSize(AssertionInfo info,
boolean[] actual,
int expectedSize)
Asserts that the number of elements in the given array is equal to the expected one.
|
void |
ByteArrays.assertHasSize(AssertionInfo info,
byte[] actual,
int expectedSize)
Asserts that the number of elements in the given array is equal to the expected one.
|
void |
CharArrays.assertHasSize(AssertionInfo info,
char[] actual,
int expectedSize)
Asserts that the number of elements in the given array is equal to the expected one.
|
void |
Strings.assertHasSize(AssertionInfo info,
CharSequence actual,
int expectedSize)
Asserts that the size of the given
CharSequence is equal to the expected one. |
void |
DoubleArrays.assertHasSize(AssertionInfo info,
double[] actual,
int expectedSize)
Asserts that the number of elements in the given array is equal to the expected one.
|
void |
FloatArrays.assertHasSize(AssertionInfo info,
float[] actual,
int expectedSize)
Asserts that the number of elements in the given array is equal to the expected one.
|
void |
IntArrays.assertHasSize(AssertionInfo info,
int[] actual,
int expectedSize)
Asserts that the number of elements in the given array is equal to the expected one.
|
void |
Iterables.assertHasSize(AssertionInfo info,
Iterable<?> actual,
int expectedSize)
Asserts that the number of elements in the given
Iterable is equal to the expected one. |
void |
LongArrays.assertHasSize(AssertionInfo info,
long[] actual,
int expectedSize)
Asserts that the number of elements in the given array is equal to the expected one.
|
void |
Maps.assertHasSize(AssertionInfo info,
Map<?,?> actual,
int expectedSize)
Asserts that the number of entries in the given
Map 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 |
BooleanArrays.assertHasSizeBetween(AssertionInfo info,
boolean[] actual,
int lowerBoundary,
int higherBoundary)
Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
|
void |
ByteArrays.assertHasSizeBetween(AssertionInfo info,
byte[] actual,
int lowerBoundary,
int higherBoundary)
Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
|
void |
CharArrays.assertHasSizeBetween(AssertionInfo info,
char[] actual,
int lowerBoundary,
int higherBoundary)
Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
|
void |
Strings.assertHasSizeBetween(AssertionInfo info,
CharSequence actual,
int lowerBoundary,
int higherBoundary)
Asserts that the size of the given
CharSequence is between the given lower and higher boundary (inclusive). |
void |
DoubleArrays.assertHasSizeBetween(AssertionInfo info,
double[] actual,
int lowerBoundary,
int higherBoundary)
Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
|
void |
FloatArrays.assertHasSizeBetween(AssertionInfo info,
float[] actual,
int lowerBoundary,
int higherBoundary)
Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
|
void |
IntArrays.assertHasSizeBetween(AssertionInfo info,
int[] actual,
int lowerBoundary,
int higherBoundary)
Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
|
void |
Iterables.assertHasSizeBetween(AssertionInfo info,
Iterable<?> actual,
int lowerBoundary,
int higherBoundary)
Asserts that the number of elements in the given
Iterable is between the given lower and higher boundary (inclusive). |
void |
LongArrays.assertHasSizeBetween(AssertionInfo info,
long[] actual,
int lowerBoundary,
int higherBoundary)
Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
|
void |
Maps.assertHasSizeBetween(AssertionInfo info,
Map<?,?> actual,
int lowerBoundary,
int higherBoundary)
Asserts that the number of entries in the given
Map is between the given lower and higher boundary (inclusive). |
void |
ObjectArrays.assertHasSizeBetween(AssertionInfo info,
Object[] actual,
int lowerBoundary,
int higherBoundary)
Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
|
void |
ShortArrays.assertHasSizeBetween(AssertionInfo info,
short[] actual,
int lowerBoundary,
int higherBoundary)
Asserts that the number of elements in the given array is between the given lower and higher boundary (inclusive).
|
void |
BooleanArrays.assertHasSizeGreaterThan(AssertionInfo info,
boolean[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than the given boundary.
|
void |
ByteArrays.assertHasSizeGreaterThan(AssertionInfo info,
byte[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than the given boundary.
|
void |
CharArrays.assertHasSizeGreaterThan(AssertionInfo info,
char[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than the given boundary.
|
void |
Strings.assertHasSizeGreaterThan(AssertionInfo info,
CharSequence actual,
int expectedMinSizeExcluded)
Asserts that the size of the given
CharSequence is greater than the expected size |
void |
DoubleArrays.assertHasSizeGreaterThan(AssertionInfo info,
double[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than the given boundary.
|
void |
FloatArrays.assertHasSizeGreaterThan(AssertionInfo info,
float[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than the given boundary.
|
void |
IntArrays.assertHasSizeGreaterThan(AssertionInfo info,
int[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than the given boundary.
|
void |
Iterables.assertHasSizeGreaterThan(AssertionInfo info,
Iterable<?> actual,
int boundary)
Asserts that the number of elements in the given
Iterable is greater than the boundary. |
void |
LongArrays.assertHasSizeGreaterThan(AssertionInfo info,
long[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than the given boundary.
|
void |
Maps.assertHasSizeGreaterThan(AssertionInfo info,
Map<?,?> actual,
int boundary)
Asserts that the number of entries in the given
Map is greater than the boundary. |
void |
ObjectArrays.assertHasSizeGreaterThan(AssertionInfo info,
Object[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than the given boundary.
|
void |
ShortArrays.assertHasSizeGreaterThan(AssertionInfo info,
short[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than the given boundary.
|
void |
BooleanArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info,
boolean[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than or equal to the given boundary.
|
void |
ByteArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info,
byte[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than or equal to the given boundary.
|
void |
CharArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info,
char[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than or equal to the given boundary.
|
void |
Strings.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info,
CharSequence actual,
int expectedMinSizeIncluded)
Asserts that the size of the given
CharSequence is greater than or equal to the expected size |
void |
DoubleArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info,
double[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than or equal to the given boundary.
|
void |
FloatArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info,
float[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than or equal to the given boundary.
|
void |
IntArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info,
int[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than or equal to the given boundary.
|
void |
Iterables.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info,
Iterable<?> actual,
int boundary)
Asserts that the number of elements in the given
Iterable is greater than or equal to the boundary. |
void |
LongArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info,
long[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than or equal to the given boundary.
|
void |
Maps.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info,
Map<?,?> actual,
int boundary)
Asserts that the number of entries in the given
Map is greater than or equal to the boundary. |
void |
ObjectArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info,
Object[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than or equal to the given boundary.
|
void |
ShortArrays.assertHasSizeGreaterThanOrEqualTo(AssertionInfo info,
short[] actual,
int boundary)
Asserts that the number of elements in the given array is greater than or equal to the given boundary.
|
void |
BooleanArrays.assertHasSizeLessThan(AssertionInfo info,
boolean[] actual,
int boundary)
Asserts that the number of elements in the given array is less than the given boundary.
|
void |
ByteArrays.assertHasSizeLessThan(AssertionInfo info,
byte[] actual,
int boundary)
Asserts that the number of elements in the given array is less than the given boundary.
|
void |
CharArrays.assertHasSizeLessThan(AssertionInfo info,
char[] actual,
int boundary)
Asserts that the number of elements in the given array is less than the given boundary.
|
void |
Strings.assertHasSizeLessThan(AssertionInfo info,
CharSequence actual,
int expectedMaxSizeExcluded)
Asserts that the size of the given
CharSequence is less than the expected size |
void |
DoubleArrays.assertHasSizeLessThan(AssertionInfo info,
double[] actual,
int boundary)
Asserts that the number of elements in the given array is less than the given boundary.
|
void |
FloatArrays.assertHasSizeLessThan(AssertionInfo info,
float[] actual,
int boundary)
Asserts that the number of elements in the given array is less than the given boundary.
|
void |
IntArrays.assertHasSizeLessThan(AssertionInfo info,
int[] actual,
int boundary)
Asserts that the number of elements in the given array is less than the given boundary.
|
void |
Iterables.assertHasSizeLessThan(AssertionInfo info,
Iterable<?> actual,
int boundary)
Asserts that the number of elements in the given
Iterable is less than the boundary. |
void |
LongArrays.assertHasSizeLessThan(AssertionInfo info,
long[] actual,
int boundary)
Asserts that the number of elements in the given array is less than the given boundary.
|
void |
Maps.assertHasSizeLessThan(AssertionInfo info,
Map<?,?> actual,
int boundary)
Asserts that the number of entries in the given
Map is less than the boundary. |
void |
ObjectArrays.assertHasSizeLessThan(AssertionInfo info,
Object[] actual,
int boundary)
Asserts that the number of elements in the given array is less than the given boundary.
|
void |
ShortArrays.assertHasSizeLessThan(AssertionInfo info,
short[] actual,
int boundary)
Asserts that the number of elements in the given array is less than the given boundary.
|
void |
BooleanArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info,
boolean[] actual,
int boundary)
Asserts that the number of elements in the given array is less than or equal to the given boundary.
|
void |
ByteArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info,
byte[] actual,
int boundary)
Asserts that the number of elements in the given array is less than or equal to the given boundary.
|
void |
CharArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info,
char[] actual,
int boundary)
Asserts that the number of elements in the given array is less than or equal to the given boundary.
|
void |
Strings.assertHasSizeLessThanOrEqualTo(AssertionInfo info,
CharSequence actual,
int expectedMaxSizeIncluded)
Asserts that the size of the given
CharSequence is less than or equal to the expected size |
void |
DoubleArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info,
double[] actual,
int boundary)
Asserts that the number of elements in the given array is less than or equal to the given boundary.
|
void |
FloatArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info,
float[] actual,
int boundary)
Asserts that the number of elements in the given array is less than or equal to the given boundary.
|
void |
IntArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info,
int[] actual,
int boundary)
Asserts that the number of elements in the given array is less than or equal to the given boundary.
|
void |
Iterables.assertHasSizeLessThanOrEqualTo(AssertionInfo info,
Iterable<?> actual,
int boundary)
Asserts that the number of elements in the given
Iterable is less than or equal to the boundary. |
void |
LongArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info,
long[] actual,
int boundary)
Asserts that the number of elements in the given array is less than or equal to the given boundary.
|
void |
Maps.assertHasSizeLessThanOrEqualTo(AssertionInfo info,
Map<?,?> actual,
int boundary)
Asserts that the number of entries in the given
Map is less than or equal to the boundary. |
void |
ObjectArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info,
Object[] actual,
int boundary)
Asserts that the number of elements in the given array is less than or equal to the given boundary.
|
void |
ShortArrays.assertHasSizeLessThanOrEqualTo(AssertionInfo info,
short[] actual,
int boundary)
Asserts that the number of elements in the given array is less than or equal to the given boundary.
|
void |
Throwables.assertHasStackTraceContaining(AssertionInfo info,
Throwable actual,
String description)
Asserts that the stack trace of the actual
Throwable contains with the given description. |
void |
Throwables.assertHasSuppressedException(AssertionInfo info,
Throwable actual,
Throwable expectedSuppressedException) |
void |
Dates.assertHasTime(AssertionInfo info,
Date actual,
long timestamp)
Verifies that the actual
Date time is equal to the given timestamp. |
void |
Objects.assertHasToString(AssertionInfo info,
Object actual,
String expectedToString) |
void |
Uris.assertHasUserInfo(AssertionInfo info,
URI actual,
String expected) |
void |
Urls.assertHasUserInfo(AssertionInfo info,
URL actual,
String expected) |
<V> void |
Maps.assertHasValueSatisfying(AssertionInfo info,
Map<?,V> actual,
Condition<? super V> valueCondition)
Verifies that the given
Map contains an entry with value satisfying valueCondition . |
void |
Dates.assertHasYear(AssertionInfo info,
Date actual,
int year)
Verifies that the actual
Date year is equal to the given year. |
<E> void |
ObjectArrays.assertHave(AssertionInfo info,
E[] actual,
Condition<? super E> condition)
Assert that each element of given array satisfies the given condition.
|
<E> void |
Arrays.assertHave(AssertionInfo info,
Failures failures,
Conditions conditions,
Object array,
Condition<E> condition) |
<E> void |
Iterables.assertHave(AssertionInfo info,
Iterable<? extends E> actual,
Condition<? super E> condition)
Assert that each element of given
Iterable satisfies the given condition. |
<E> void |
ObjectArrays.assertHaveAtLeast(AssertionInfo info,
E[] actual,
int times,
Condition<? super E> condition)
An alias method of
ObjectArrays.assertAreAtLeast(AssertionInfo, Object[], int, Condition) to provide a richer fluent
api (same logic, only error message differs). |
<E> void |
Arrays.assertHaveAtLeast(AssertionInfo info,
Failures failures,
Conditions conditions,
Object array,
int times,
Condition<E> condition) |
<E> void |
Iterables.assertHaveAtLeast(AssertionInfo info,
Iterable<? extends E> actual,
int times,
Condition<? super E> condition)
An alias method of
Iterables.assertAreAtLeast(AssertionInfo, Iterable, int, Condition) to provide a richer fluent
api (same logic, only error message differs). |
<E> void |
ObjectArrays.assertHaveAtMost(AssertionInfo info,
E[] actual,
int times,
Condition<? super E> condition)
An alias method of
ObjectArrays.assertAreAtMost(AssertionInfo, Object[], int, Condition) to provide a richer fluent api
(same logic, only error message differs). |
<E> void |
Arrays.assertHaveAtMost(AssertionInfo info,
Failures failures,
Conditions conditions,
Object array,
int times,
Condition<E> condition) |
<E> void |
Iterables.assertHaveAtMost(AssertionInfo info,
Iterable<? extends E> actual,
int times,
Condition<? super E> condition)
An alias method of
Iterables.assertAreAtMost(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api
(same logic, only error message differs). |
<E> void |
ObjectArrays.assertHaveExactly(AssertionInfo info,
E[] actual,
int times,
Condition<? super E> condition)
An alias method of
ObjectArrays.assertAreExactly(AssertionInfo, Object[], int, Condition) to provide a richer fluent
api (same logic, only error message differs). |
<E> void |
Arrays.assertHaveExactly(AssertionInfo info,
Failures failures,
Conditions conditions,
Object array,
int times,
Condition<E> condition) |
<E> void |
Iterables.assertHaveExactly(AssertionInfo info,
Iterable<? extends E> actual,
int times,
Condition<? super E> condition)
An alias method of
Iterables.assertAreExactly(AssertionInfo, Iterable, int, Condition) to provide a richer fluent
api (same logic, only error message differs). |
<E> void |
Arrays.assertHaveNot(AssertionInfo info,
Failures failures,
Conditions conditions,
Object array,
Condition<E> condition) |
protected String |
Failures.assertionErrorMessage(AssertionInfo info,
ErrorMessageFactory messageFactory) |
<T> void |
Lists.assertIs(AssertionInfo info,
List<? extends T> actual,
Condition<? super T> condition,
Index index)
Verifies that the given
List satisfies the given at the given index. |
<T> void |
Conditions.assertIs(AssertionInfo info,
T actual,
Condition<? super T> condition)
Asserts that the actual value satisfies the given
. |
void |
Files.assertIsAbsolute(AssertionInfo info,
File actual)
Asserts that the given file is an absolute path.
|
void |
Paths.assertIsAbsolute(AssertionInfo info,
Path actual) |
void |
Classes.assertIsAbstract(AssertionInfo info,
Class<?> actual)
Verifies that the actual
Class is abstract. |
void |
Dates.assertIsAfter(AssertionInfo info,
Date actual,
Date other)
Verifies that the actual
Date is strictly after the given one. |
void |
Dates.assertIsAfterOrEqualsTo(AssertionInfo info,
Date actual,
Date other)
Verifies that the actual
Date is after or equal to the given one. |
void |
Dates.assertIsAfterYear(AssertionInfo info,
Date actual,
int year)
Verifies that the actual
Date is strictly after the given year. |
void |
Classes.assertIsAnnotation(AssertionInfo info,
Class<?> actual)
Verifies that the actual
Class is an annotation. |
static void |
Arrays.assertIsArray(AssertionInfo info,
Object array) |
void |
Classes.assertIsAssignableFrom(AssertionInfo info,
Class<?> actual,
Class<?>... others)
Verifies that the actual
Class is assignable from all the others classes. |
void |
Dates.assertIsBefore(AssertionInfo info,
Date actual,
Date other)
Verifies that the actual
Date is strictly before the given one. |
void |
Dates.assertIsBeforeOrEqualsTo(AssertionInfo info,
Date actual,
Date other)
Verifies that the actual
Date is before or equal to the given one. |
void |
Dates.assertIsBeforeYear(AssertionInfo info,
Date actual,
int year)
Verifies that the actual
Date is strictly before the given year. |
void |
Dates.assertIsBetween(AssertionInfo info,
Date actual,
Date start,
Date end,
boolean inclusiveStart,
boolean inclusiveEnd)
Verifies that the actual
Date is in start:end period.start date belongs to the period if inclusiveStart is true. end date belongs to the period if inclusiveEnd is true. |
void |
Numbers.assertIsBetween(AssertionInfo info,
NUMBER actual,
NUMBER start,
NUMBER end)
Asserts that the actual value is in [start, end] range (start included, end included).
|
<T extends Comparable<? super T>> |
Comparables.assertIsBetween(AssertionInfo info,
T actual,
T start,
T end,
boolean inclusiveStart,
boolean inclusiveEnd)
Asserts that the actual value is between start and end, inclusive or not.
|
void |
Futures.assertIsCancelled(AssertionInfo info,
Future<?> actual)
Verifies that the
Future is cancelled. |
void |
Paths.assertIsCanonical(AssertionInfo info,
Path actual) |
void |
Dates.assertIsCloseTo(AssertionInfo info,
Date actual,
Date other,
long deltaInMilliseconds)
Verifies that the actual
Date is close to the other date by less than delta, if difference is equals to delta it is
ok.Note that delta expressed in milliseconds. Use handy TimeUnit to convert a duration in milliseconds, for example you can express a delta of 5 seconds with TimeUnit.SECONDS.toMillis(5) . |
void |
Numbers.assertIsCloseTo(AssertionInfo info,
NUMBER actual,
NUMBER expected,
Offset<NUMBER> offset)
Asserts that the actual value is close to the expected one by less than the given offset.
|
void |
Numbers.assertIsCloseToPercentage(AssertionInfo info,
NUMBER actual,
NUMBER other,
Percentage percentage)
Asserts that the actual value is close to the an offset expressed as an percentage value.
|
void |
Files.assertIsDirectory(AssertionInfo info,
File actual)
Asserts that the given file is an existing directory.
|
void |
Paths.assertIsDirectory(AssertionInfo info,
Path actual) |
void |
Futures.assertIsDone(AssertionInfo info,
Future<?> actual)
Verifies that the
Future is done. |
<A> void |
Objects.assertIsEqualToComparingFieldByFieldRecursively(AssertionInfo info,
Object actual,
Object other,
Map<String,Comparator<?>> comparatorByPropertyOrField,
TypeComparators comparatorByType)
Assert that the given object is "deeply" equals to other by comparing all fields recursively.
|
<A> void |
Objects.assertIsEqualToComparingOnlyGivenFields(AssertionInfo info,
A actual,
A other,
Map<String,Comparator<?>> comparatorByPropertyOrField,
TypeComparators comparatorByType,
String... fields)
Assert that the given object is lenient equals to other object by comparing given fields value only.
|
<A> void |
Objects.assertIsEqualToIgnoringGivenFields(AssertionInfo info,
A actual,
A other,
Map<String,Comparator<?>> comparatorByPropertyOrField,
TypeComparators comparatorByType,
String... fields)
Assert that the given object is lenient equals to the other by comparing all fields (including inherited fields)
unless given ignored ones.
|
void |
Strings.assertIsEqualToIgnoringNewLines(AssertionInfo info,
CharSequence actual,
CharSequence expected)
Verifies that actual is equal to expected ignoring new lines
|
<A> void |
Objects.assertIsEqualToIgnoringNullFields(AssertionInfo info,
A actual,
A other,
Map<String,Comparator<?>> comparatorByPropertyOrField,
TypeComparators comparatorByType)
Assert that the given object is lenient equals by ignoring null fields value on other object (including inherited
fields).
|
void |
Strings.assertIsEqualToNormalizingNewlines(AssertionInfo info,
CharSequence actual,
CharSequence expected)
Verifies that two
CharSequence s are not equal, normalizing newlines. |
void |
Dates.assertIsEqualWithPrecision(AssertionInfo info,
Date actual,
Date other,
TimeUnit precision)
Verifies that the actual
Date is equal to the given one with precision. |
void |
Objects.assertIsExactlyInstanceOf(AssertionInfo info,
Object actual,
Class<?> type)
Verifies that the actual value is exactly an instance of given type.
|
void |
Paths.assertIsExecutable(AssertionInfo info,
Path actual) |
void |
Iterators.assertIsExhausted(AssertionInfo info,
Iterator<?> actual) |
void |
Files.assertIsFile(AssertionInfo info,
File actual)
Asserts that the given file is an existing file.
|
void |
Classes.assertIsFinal(AssertionInfo info,
Class<?> actual)
Verifies that the actual
Class is final. |
void |
Objects.assertIsIn(AssertionInfo info,
Object actual,
Iterable<?> values)
Asserts that the given object is present in the given collection.
|
void |
Objects.assertIsIn(AssertionInfo info,
Object actual,
Object[] values)
Asserts that the given object is present in the given array.
|
void |
Dates.assertIsInSameDayAs(AssertionInfo info,
Date actual,
Date other)
Verifies that actual and given
Date are chronologically in the same day of month (and thus in the same month and
year). |
void |
Dates.assertIsInSameHourAs(AssertionInfo info,
Date actual,
Date other)
Verifies that actual and given
Date are in the same hour (and thus in the same day of month, month
and year). |
void |
Dates.assertIsInSameHourWindowAs(AssertionInfo info,
Date actual,
Date other)
Verifies that actual and given
Date are chronologically in the same hour, day of month, month and year. |
void |
Dates.assertIsInSameMinuteAs(AssertionInfo info,
Date actual,
Date other)
Verifies that actual and given
Date are in the same minute, hour, day of month, month and year. |
void |
Dates.assertIsInSameMinuteWindowAs(AssertionInfo info,
Date actual,
Date other)
Verifies that actual and given
Date are chronologically in the same minute. |
void |
Dates.assertIsInSameMonthAs(AssertionInfo info,
Date actual,
Date other)
Verifies that actual and given
Date are chronologically in the same month (and thus in the same year). |
void |
Dates.assertIsInSameSecondAs(AssertionInfo info,
Date actual,
Date other)
Verifies that actual and given
Date are in the same second, minute, hour, day of month, month and year. |
void |
Dates.assertIsInSameSecondWindowAs(AssertionInfo info,
Date actual,
Date other)
Verifies that actual and given
Date are chronologically in the same second. |
void |
Dates.assertIsInSameYearAs(AssertionInfo info,
Date actual,
Date other)
Verifies that actual and given
Date are in the same year. |
void |
Objects.assertIsInstanceOf(AssertionInfo info,
Object actual,
Class<?> type)
Verifies that the given object is an instance of the given type.
|
void |
Objects.assertIsInstanceOfAny(AssertionInfo info,
Object actual,
Class<?>[] types)
Verifies that the given object is an instance of any of the given types.
|
void |
Classes.assertIsInterface(AssertionInfo info,
Class<?> actual)
Verifies that the actual
Class is an interface. |
void |
Dates.assertIsInTheFuture(AssertionInfo info,
Date actual)
Verifies that the actual
Date is strictly in the future. |
void |
Dates.assertIsInThePast(AssertionInfo info,
Date actual)
Verifies that the actual
Date is strictly in the past. |
void |
RealNumbers.assertIsNaN(AssertionInfo info,
NUMBER actual)
Verifies that the actual value is equal to
NaN .It does not rely on the custom comparisonStrategy (if one is set). |
void |
Numbers.assertIsNegative(AssertionInfo info,
NUMBER actual)
Asserts that the actual value is negative.
|
void |
Paths.assertIsNormalized(AssertionInfo info,
Path actual) |
<T> void |
Conditions.assertIsNot(AssertionInfo info,
T actual,
Condition<? super T> condition)
Asserts that the actual value does not satisfy the given
. |
void |
Classes.assertIsNotAnnotation(AssertionInfo info,
Class<?> actual)
Verifies that the actual
Class is not an annotation. |
void |
Dates.assertIsNotBetween(AssertionInfo info,
Date actual,
Date start,
Date end,
boolean inclusiveStart,
boolean inclusiveEnd)
Verifies that the actual
Date is not in start:end period..start date belongs to the period if inclusiveStart is true. end date belongs to the period if inclusiveEnd is true. |
void |
Futures.assertIsNotCancelled(AssertionInfo info,
Future<?> actual)
Verifies that the
Future is not cancelled. |
void |
Numbers.assertIsNotCloseTo(AssertionInfo info,
NUMBER actual,
NUMBER expected,
Offset<NUMBER> offset)
Asserts that the actual value is not close to the expected one by less than the given offset.
|
void |
Numbers.assertIsNotCloseToPercentage(AssertionInfo info,
NUMBER actual,
NUMBER other,
Percentage percentage)
Asserts that the actual value is not close to the an offset expressed as an percentage value.
|
void |
Futures.assertIsNotDone(AssertionInfo info,
Future<?> actual)
Verifies that the
Future is not done. |
void |
Objects.assertIsNotExactlyInstanceOf(AssertionInfo info,
Object actual,
Class<?> type)
Verifies that the actual value is not exactly an instance of given type.
|
void |
Classes.assertIsNotFinal(AssertionInfo info,
Class<?> actual)
Verifies that the actual
Class is not final. |
void |
Objects.assertIsNotIn(AssertionInfo info,
Object actual,
Iterable<?> values)
Asserts that the given object is not present in the given collection.
|
void |
Objects.assertIsNotIn(AssertionInfo info,
Object actual,
Object[] values)
Asserts that the given object is not present in the given array.
|
void |
Objects.assertIsNotInstanceOf(AssertionInfo info,
Object actual,
Class<?> type)
Verifies that the given object is not an instance of the given type.
|
void |
Objects.assertIsNotInstanceOfAny(AssertionInfo info,
Object actual,
Class<?>[] types)
Verifies that the given object is not an instance of any of the given types.
|
void |
Classes.assertIsNotInterface(AssertionInfo info,
Class<?> actual)
Verifies that the actual
Class is not an interface. |
void |
RealNumbers.assertIsNotNaN(AssertionInfo info,
NUMBER actual)
Verifies that the actual value is not equal to
NaN . |
void |
Numbers.assertIsNotNegative(AssertionInfo info,
NUMBER actual)
Asserts that the actual value is not negative.
|
void |
Objects.assertIsNotOfAnyClassIn(AssertionInfo info,
Object actual,
Class<?>[] types)
Verifies that the actual value type is not in given types.
|
void |
Numbers.assertIsNotPositive(AssertionInfo info,
NUMBER actual)
Asserts that the actual value is not positive.
|
void |
Numbers.assertIsNotZero(AssertionInfo info,
NUMBER actual)
Asserts that the actual value is not equal to zero.
It does not rely on the custom comparisonStrategy (if one is set). |
void |
Objects.assertIsOfAnyClassIn(AssertionInfo info,
Object actual,
Class<?>[] types)
Verifies that the actual value type is in given types.
|
void |
Numbers.assertIsOne(AssertionInfo info,
NUMBER actual)
Asserts that the actual value is equal to one.
It does not rely on the custom comparisonStrategy (if one is set). |
void |
Numbers.assertIsPositive(AssertionInfo info,
NUMBER actual)
Asserts that the actual value is positive.
|
void |
Classes.assertIsProtected(AssertionInfo info,
Class<?> actual)
Verifies that the actual
Class is protected. |
void |
Classes.assertIsPublic(AssertionInfo info,
Class<?> actual)
Verifies that the actual
Class is public. |
void |
Paths.assertIsReadable(AssertionInfo info,
Path actual) |
void |
Paths.assertIsRegularFile(AssertionInfo info,
Path actual) |
void |
Files.assertIsRelative(AssertionInfo info,
File actual)
Asserts that the given file is a relative path.
|
void |
Paths.assertIsRelative(AssertionInfo info,
Path actual) |
void |
BooleanArrays.assertIsSorted(AssertionInfo info,
boolean[] actual)
Concrete implementation of
ArraySortedAssert.isSorted() . |
void |
ByteArrays.assertIsSorted(AssertionInfo info,
byte[] actual)
Concrete implementation of
ArraySortedAssert.isSorted() . |
void |
CharArrays.assertIsSorted(AssertionInfo info,
char[] actual)
Concrete implementation of
ArraySortedAssert.isSorted() . |
void |
DoubleArrays.assertIsSorted(AssertionInfo info,
double[] actual)
Concrete implementation of
ArraySortedAssert.isSorted() . |
void |
FloatArrays.assertIsSorted(AssertionInfo info,
float[] actual)
Concrete implementation of
ArraySortedAssert.isSorted() . |
void |
IntArrays.assertIsSorted(AssertionInfo info,
int[] actual)
Concrete implementation of
ArraySortedAssert.isSorted() . |
void |
Lists.assertIsSorted(AssertionInfo info,
List<?> actual)
Verifies that the actual list is sorted in ascending order according to the natural ordering of its elements.
|
void |
LongArrays.assertIsSorted(AssertionInfo info,
long[] actual)
Concrete implementation of
ArraySortedAssert.isSorted() . |
void |
ObjectArrays.assertIsSorted(AssertionInfo info,
Object[] actual)
Concrete implementation of
ArraySortedAssert.isSorted() . |
void |
ShortArrays.assertIsSorted(AssertionInfo info,
short[] actual)
Concrete implementation of
ArraySortedAssert.isSorted() . |
void |
BooleanArrays.assertIsSortedAccordingToComparator(AssertionInfo info,
boolean[] actual,
Comparator<? super Boolean> comparator)
Concrete implementation of
ArraySortedAssert.isSortedAccordingTo(Comparator) . |
void |
ByteArrays.assertIsSortedAccordingToComparator(AssertionInfo info,
byte[] actual,
Comparator<? super Byte> comparator)
Concrete implementation of
ArraySortedAssert.isSortedAccordingTo(Comparator) . |
void |
CharArrays.assertIsSortedAccordingToComparator(AssertionInfo info,
char[] actual,
Comparator<? super Character> comparator)
Concrete implementation of
ArraySortedAssert.isSortedAccordingTo(Comparator) . |
void |
DoubleArrays.assertIsSortedAccordingToComparator(AssertionInfo info,
double[] actual,
Comparator<? super Double> comparator)
Concrete implementation of
ArraySortedAssert.isSortedAccordingTo(Comparator) . |
<E> void |
ObjectArrays.assertIsSortedAccordingToComparator(AssertionInfo info,
E[] actual,
Comparator<? super E> comparator)
Concrete implementation of
ArraySortedAssert.isSortedAccordingTo(Comparator) . |
void |
FloatArrays.assertIsSortedAccordingToComparator(AssertionInfo info,
float[] actual,
Comparator<? super Float> comparator)
Concrete implementation of
ArraySortedAssert.isSortedAccordingTo(Comparator) . |
void |
IntArrays.assertIsSortedAccordingToComparator(AssertionInfo info,
int[] actual,
Comparator<? super Integer> comparator)
Concrete implementation of
ArraySortedAssert.isSortedAccordingTo(Comparator) . |
void |
Lists.assertIsSortedAccordingToComparator(AssertionInfo info,
List<?> actual,
Comparator<?> comparator)
Verifies that the actual list is sorted according to the given comparator.
Empty lists are considered sorted whatever the comparator is. One element lists are considered sorted if the element is compatible with comparator. |
void |
LongArrays.assertIsSortedAccordingToComparator(AssertionInfo info,
long[] actual,
Comparator<? super Long> comparator)
Concrete implementation of
ArraySortedAssert.isSortedAccordingTo(Comparator) . |
void |
ShortArrays.assertIsSortedAccordingToComparator(AssertionInfo info,
short[] actual,
Comparator<? super Short> comparator)
Concrete implementation of
ArraySortedAssert.isSortedAccordingTo(Comparator) . |
void |
Numbers.assertIsStrictlyBetween(AssertionInfo info,
NUMBER actual,
NUMBER start,
NUMBER end)
Asserts that the actual value is in ]start, end[ range (start excluded, end excluded).
|
void |
Arrays.assertIsSubsetOf(AssertionInfo info,
Failures failures,
Object actual,
Iterable<?> values) |
void |
Iterables.assertIsSubsetOf(AssertionInfo info,
Iterable<?> actual,
Iterable<?> values)
Verifies that the actual
Iterable is a subset of values Iterable . |
void |
ObjectArrays.assertIsSubsetOf(AssertionInfo info,
Object actual,
Iterable<?> values) |
void |
Strings.assertIsSubstringOf(AssertionInfo info,
CharSequence actual,
CharSequence sequence) |
void |
Paths.assertIsSymbolicLink(AssertionInfo info,
Path actual) |
void |
Dates.assertIsToday(AssertionInfo info,
Date actual)
Verifies that the actual
Date is today, by comparing only year, month and day of actual to today (ie. |
void |
Paths.assertIsWritable(AssertionInfo info,
Path actual) |
void |
Numbers.assertIsZero(AssertionInfo info,
NUMBER actual)
Asserts that the actual value is equal to zero.
It does not rely on the custom comparisonStrategy (if one is set). |
void |
Strings.assertJavaBlank(AssertionInfo info,
CharSequence actual)
Asserts that the given
CharSequence consists of one or more whitespace characters
according to Character.isWhitespace(char) . |
<T extends Comparable<? super T>> |
Comparables.assertLessThan(AssertionInfo info,
T actual,
T other)
Asserts that the actual value is less than the other one.
|
<T extends Comparable<? super T>> |
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,
Character actual)
Asserts that the actual value is a lowercase character.
|
void |
Strings.assertLowerCase(AssertionInfo info,
CharSequence actual) |
void |
Strings.assertMatches(AssertionInfo info,
CharSequence actual,
CharSequence regex)
Verifies that the given
CharSequence matches the given regular expression. |
void |
Strings.assertMatches(AssertionInfo info,
CharSequence actual,
Pattern pattern)
Verifies that the given
CharSequence matches the given regular expression. |
<E> void |
Iterables.assertNoneMatch(AssertionInfo info,
Iterable<? extends E> actual,
Predicate<? super E> predicate,
PredicateDescription predicateDescription) |
<E> void |
Iterables.assertNoneSatisfy(AssertionInfo info,
Iterable<? extends E> actual,
Consumer<? super E> restrictions) |
<K,V> void |
Maps.assertNoneSatisfy(AssertionInfo info,
Map<K,V> actual,
BiConsumer<? super K,? super V> entryRequirements) |
void |
Strings.assertNotBlank(AssertionInfo info,
CharSequence actual)
Asserts that the given
CharSequence contains at least one non-whitespace character. |
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 |
Strings.assertNotEmpty(AssertionInfo info,
CharSequence actual)
Asserts that the given
CharSequence 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 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,
Map<?,?> actual)
Asserts that the given
Map 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 |
Booleans.assertNotEqual(AssertionInfo info,
Boolean actual,
boolean other)
Asserts that two longs are not equal.
|
void |
Objects.assertNotEqual(AssertionInfo info,
Object actual,
Object other)
Asserts that two objects are not equal.
|
<T> void |
Comparables.assertNotEqual(AssertionInfo info,
T actual,
T other)
Asserts that two T instances are not equal.
|
<T extends Comparable<? super T>> |
Comparables.assertNotEqualByComparison(AssertionInfo info,
T actual,
T other)
Asserts that two
s are not equal by invoking
.Note that it does not rely on the custom Comparables.comparisonStrategy if one has been set. |
void |
Strings.assertNotEqualsIgnoringCase(AssertionInfo info,
CharSequence actual,
CharSequence expected)
Verifies that two
CharSequence s are not equal, ignoring case considerations. |
void |
Strings.assertNotEqualsIgnoringWhitespace(AssertionInfo info,
CharSequence actual,
CharSequence expected)
Verifies that two
CharSequence s are not equal, ignoring any differences in whitespace. |
void |
Strings.assertNotEqualsNormalizingWhitespace(AssertionInfo info,
CharSequence actual,
CharSequence expected)
Verifies that two
CharSequence s are not equal, after the whitespace of both strings
has been normalized. |
void |
Strings.assertNotJavaBlank(AssertionInfo info,
CharSequence actual)
Asserts that the given
CharSequence is Null , empty or contains at least one non-whitespace character
according to Character.isWhitespace(char) . |
void |
Objects.assertNotNull(AssertionInfo info,
Object actual)
Asserts that the given object is not
null . |
void |
Objects.assertNotNull(AssertionInfo info,
Object actual,
String label)
Asserts that the given object is not
null . |
protected static <T> void |
Comparables.assertNotNull(AssertionInfo info,
T actual) |
void |
Objects.assertNotSame(AssertionInfo info,
Object actual,
Object other)
Asserts that two objects do not refer to the same object.
|
void |
Objects.assertNull(AssertionInfo info,
Object actual)
Asserts that the given object 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 |
Strings.assertNullOrEmpty(AssertionInfo info,
CharSequence actual)
Asserts that the given
CharSequence 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,
Iterable<?> actual)
Asserts that the given
is null or empty. |
void |
LongArrays.assertNullOrEmpty(AssertionInfo info,
long[] actual)
Asserts that the given array is
null or empty. |
void |
Maps.assertNullOrEmpty(AssertionInfo info,
Map<?,?> actual)
Asserts that the given
Map is null or empty. |
void |
ObjectArrays.assertNullOrEmpty(AssertionInfo info,
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 |
Objects.assertSame(AssertionInfo info,
Object actual,
Object expected)
Asserts that two objects refer to the same object.
|
void |
Files.assertSameContentAs(AssertionInfo info,
File actual,
Charset actualCharset,
File expected,
Charset expectedCharset)
Asserts that the given files have same content.
|
void |
InputStreams.assertSameContentAs(AssertionInfo info,
InputStream actual,
InputStream expected)
Asserts that the given InputStreams have same content.
|
<T> void |
Conditions.assertSatisfies(AssertionInfo info,
T actual,
Condition<? super T> condition) |
void |
BooleanArrays.assertStartsWith(AssertionInfo info,
boolean[] actual,
boolean[] sequence)
Verifies that the given array starts with the given sequence of values, without any other values between them.
|
void |
ByteArrays.assertStartsWith(AssertionInfo info,
byte[] actual,
byte[] sequence)
Verifies that the given array starts with the given sequence of values, without any other values between them.
|
void |
ByteArrays.assertStartsWith(AssertionInfo info,
byte[] actual,
int[] sequence)
Verifies that the given array starts with the given sequence of values, without any other values between them.
|
void |
CharArrays.assertStartsWith(AssertionInfo info,
char[] actual,
char[] sequence)
Verifies that the given array starts with the given sequence of values, without any other values between them.
|
void |
Strings.assertStartsWith(AssertionInfo info,
CharSequence actual,
CharSequence prefix)
Verifies that the given
CharSequence starts with the given prefix. |
void |
DoubleArrays.assertStartsWith(AssertionInfo info,
double[] actual,
double[] sequence)
Verifies that the given array starts with the given sequence of values, without any other values between them.
|
void |
FloatArrays.assertStartsWith(AssertionInfo info,
float[] actual,
float[] sequence)
Verifies that the given array starts with the given sequence of values, without any other values between them.
|
void |
IntArrays.assertStartsWith(AssertionInfo info,
int[] actual,
int[] sequence)
Verifies that the given array starts with the given sequence of values, without any other values between them.
|
void |
Iterables.assertStartsWith(AssertionInfo info,
Iterable<?> actual,
Object[] sequence)
Verifies that the given
Iterable starts with the given sequence of objects, without any other objects
between them. |
void |
LongArrays.assertStartsWith(AssertionInfo info,
long[] actual,
long[] sequence)
Verifies that the given array starts with the given sequence of values, without any other values between them.
|
void |
ObjectArrays.assertStartsWith(AssertionInfo info,
Object[] actual,
Object[] sequence)
Verifies that the given array starts with the given sequence of objects, without any other objects between them.
|
void |
Paths.assertStartsWith(AssertionInfo info,
Path actual,
Path start) |
void |
ShortArrays.assertStartsWith(AssertionInfo info,
short[] actual,
short[] sequence)
Verifies that the given array starts with the given sequence of values, without any other values between them.
|
void |
Paths.assertStartsWithRaw(AssertionInfo info,
Path actual,
Path other) |
void |
Characters.assertUpperCase(AssertionInfo info,
Character actual)
Asserts that the actual value is a uppercase character.
|
void |
Strings.assertUpperCase(AssertionInfo info,
CharSequence actual) |
void |
Strings.assertXmlEqualsTo(AssertionInfo info,
CharSequence actualXml,
CharSequence expectedXml) |
<ACTUAL_ELEMENT,OTHER_ELEMENT> |
Iterables.assertZipSatisfy(AssertionInfo info,
Iterable<? extends ACTUAL_ELEMENT> actual,
Iterable<OTHER_ELEMENT> other,
BiConsumer<? super ACTUAL_ELEMENT,OTHER_ELEMENT> zipRequirements) |
static void |
CommonValidations.checkLineCounts(Object actual,
int lineCountOfActual,
int lineCountOfOther,
AssertionInfo info) |
static void |
CommonValidations.checkSizeBetween(Object actual,
int lowerBoundary,
int higherBoundary,
int sizeOfActual,
AssertionInfo info) |
static void |
CommonValidations.checkSizeGreaterThan(Object actual,
int boundary,
int sizeOfActual,
AssertionInfo info) |
static void |
CommonValidations.checkSizeGreaterThanOrEqualTo(Object actual,
int boundary,
int sizeOfActual,
AssertionInfo info) |
static void |
CommonValidations.checkSizeLessThan(Object actual,
int boundary,
int sizeOfActual,
AssertionInfo info) |
static void |
CommonValidations.checkSizeLessThanOrEqualTo(Object actual,
int boundary,
int sizeOfActual,
AssertionInfo info) |
static void |
CommonValidations.checkSizes(Object actual,
int sizeOfActual,
int sizeOfOther,
AssertionInfo info) |
AssertionError |
Failures.failure(AssertionInfo info,
AssertionErrorFactory factory)
Creates a
following this pattern:
creates a using
as the error message if such value is not null , or
uses the given to create an ,
prepending the value of to the error message
|
AssertionError |
Failures.failure(AssertionInfo info,
ErrorMessageFactory messageFactory)
Creates a
following this pattern:
creates a using
as the error message if such value is not null , or
uses the given to create the detail message of the
, prepending the value of to
the error message
|
AssertionError |
Failures.failure(AssertionInfo info,
ErrorMessageFactory messageFactory,
Object actual,
Object expected) |
AssertionError |
Failures.failureIfErrorMessageIsOverridden(AssertionInfo info) |
static void |
CommonValidations.hasSameSizeAsCheck(AssertionInfo info,
Object actual,
Iterable<?> other,
int sizeOfActual) |
static void |
CommonValidations.hasSameSizeAsCheck(AssertionInfo info,
Object actual,
Map<?,?> other,
int sizeOfActual) |
static void |
CommonValidations.hasSameSizeAsCheck(AssertionInfo info,
Object actual,
Object other,
int sizeOfActual) |
void |
Dates.hasSameTimeAs(AssertionInfo info,
Date actual,
Date date)
Verifies that the actual
Date is equal to the given date by comparing their time. |
<T> void |
Lists.satisfies(AssertionInfo info,
List<? extends T> actual,
Consumer<? super T> requirements,
Index index) |
Copyright © 2014–2019 AssertJ. All rights reserved.