Uses of Interface
org.fest.assertions.core.AssertionInfo

Packages that use AssertionInfo
org.fest.assertions.core   
org.fest.assertions.internal   
 

Uses of AssertionInfo in org.fest.assertions.core
 

Classes in org.fest.assertions.core that implement AssertionInfo
 class WritableAssertionInfo
          Writable information about an assertion.
 

Uses of AssertionInfo in org.fest.assertions.internal
 

Methods in org.fest.assertions.internal with parameters of type AssertionInfo
<E> void
Iterables.assertAre(AssertionInfo info, Iterable<?> actual, Condition<E> condition)
          Assert that each element of given Iterable satisfies the given condition.
<E> void
ObjectArrays.assertAre(AssertionInfo info, Object[] actual, Condition<E> condition)
          Assert that each element of given array satisfies the given condition.
<E> void
Iterables.assertAreAtLeast(AssertionInfo info, Iterable<?> actual, int n, Condition<E> condition)
          Assert that there is at least n elements in the actual Iterable satisfying the given condition.
<E> void
ObjectArrays.assertAreAtLeast(AssertionInfo info, Object[] actual, int n, Condition<E> condition)
          Assert that there is at least n array elements satisfying the given condition.
<E> void
Iterables.assertAreAtMost(AssertionInfo info, Iterable<?> actual, int n, Condition<E> condition)
          Assert that there is at most n elements in the actual Iterable satisfying the given condition.
<E> void
ObjectArrays.assertAreAtMost(AssertionInfo info, Object[] actual, int n, Condition<E> condition)
          Assert that there is at most n array elements satisfying the given condition.
<E> void
Iterables.assertAreExactly(AssertionInfo info, Iterable<?> actual, int n, Condition<E> condition)
          Verifies that there is exactly n elements in the actual Iterable satisfying the given condition.
<E> void
ObjectArrays.assertAreExactly(AssertionInfo info, Object[] actual, int n, Condition<E> condition)
          Verifies that there is exactly n array elements satisfying the given condition.
<E> void
Iterables.assertAreNot(AssertionInfo info, Iterable<?> actual, Condition<E> condition)
          Assert that each element of given Iterable not satisfies the given condition.
<E> void
ObjectArrays.assertAreNot(AssertionInfo info, Object[] actual, Condition<E> condition)
          Assert that each element of given array not satisfies the given condition.
<E> void
Iterables.assertAreNotAtLeast(AssertionInfo info, Iterable<?> actual, int n, Condition<E> condition)
          Assert that there is at least n elements in the actual Iterable not satisfying the given condition.
<E> void
ObjectArrays.assertAreNotAtLeast(AssertionInfo info, Object[] actual, int n, Condition<E> condition)
          Assert that there is at least n array elements not satisfying the given condition.
<E> void
Iterables.assertAreNotAtMost(AssertionInfo info, Iterable<?> actual, int n, Condition<E> condition)
          Verifies that there is at most n elements in the actual Iterable not satisfying the given condition.
<E> void
ObjectArrays.assertAreNotAtMost(AssertionInfo info, Object[] actual, int n, Condition<E> condition)
          Verifies that there is at most n array elements not satisfying the given condition.
<E> void
Iterables.assertAreNotExactly(AssertionInfo info, Iterable<?> actual, int n, Condition<E> condition)
          Verifies that there is exactly n elements in the actual Iterable not satisfying the given condition.
<E> void
ObjectArrays.assertAreNotExactly(AssertionInfo info, Object[] actual, int n, Condition<E> condition)
          Verifies that there is exactly n elements in the actual Iterable not satisfying the given condition.
 void BooleanArrays.assertContains(AssertionInfo info, boolean[] actual, boolean[] values)
          Asserts that the given array contains the given values, in any order.
 void BooleanArrays.assertContains(AssertionInfo info, boolean[] actual, boolean value, Index index)
          Verifies that the given array contains the given value at the given index.
 void ByteArrays.assertContains(AssertionInfo info, byte[] actual, byte[] values)
          Asserts that the given array contains the given values, in any order.
 void ByteArrays.assertContains(AssertionInfo info, byte[] actual, byte value, Index index)
          Verifies that the given array contains the given value at the given index.
 void CharArrays.assertContains(AssertionInfo info, char[] actual, char[] values)
          Asserts that the given array contains the given values, in any order.
 void CharArrays.assertContains(AssertionInfo info, char[] actual, char value, Index index)
          Verifies that the given array contains the given value at the given index.
 void DoubleArrays.assertContains(AssertionInfo info, double[] actual, double[] values)
          Asserts that the given array contains the given values, in any order.
 void DoubleArrays.assertContains(AssertionInfo info, double[] actual, double value, Index index)
          Verifies that the given array contains the given value at the given index.
 void FloatArrays.assertContains(AssertionInfo info, float[] actual, float[] values)
          Asserts that the given array contains the given values, in any order.
 void FloatArrays.assertContains(AssertionInfo info, float[] actual, float value, Index index)
          Verifies that the given array contains the given value at the given index.
 void IntArrays.assertContains(AssertionInfo info, int[] actual, int[] values)
          Asserts that the given array contains the given values, in any order.
 void IntArrays.assertContains(AssertionInfo info, int[] actual, int value, Index index)
          Verifies that the given array contains the given value at the given index.
 void Iterables.assertContains(AssertionInfo info, Iterable<?> actual, Object[] values)
          Asserts that the 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.
 void Maps.assertContains(AssertionInfo info, Map<?,?> actual, MapEntry[] 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.
 void Strings.assertContains(AssertionInfo info, String actual, String sequence)
          Verifies that the given String contains the given sequence.
 void Strings.assertContainsIgnoringCase(AssertionInfo info, String actual, String sequence)
          Verifies that the given String contains the given sequence, ignoring case considerations.
 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 CharArrays.assertContainsOnly(AssertionInfo info, char[] actual, char[] values)
          Asserts that the given array contains only the given values and nothing else, in any order.
 void DoubleArrays.assertContainsOnly(AssertionInfo info, double[] actual, double[] values)
          Asserts that the given array contains only the given values and nothing else, in any order.
 void FloatArrays.assertContainsOnly(AssertionInfo info, float[] actual, float[] values)
          Asserts that the given array contains only the given values and nothing else, in any order.
 void IntArrays.assertContainsOnly(AssertionInfo info, int[] actual, int[] values)
          Asserts that the given array contains only the given values and nothing else, in any order.
 void Iterables.assertContainsOnly(AssertionInfo info, Iterable<?> actual, Object[] values)
          Asserts that the given Iterable contains only the given values and nothing else, in any order.
 void LongArrays.assertContainsOnly(AssertionInfo info, long[] actual, long[] values)
          Asserts that the given array contains only the given values and nothing else, in any order.
 void ObjectArrays.assertContainsOnly(AssertionInfo info, 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 BooleanArrays.assertContainsSequence(AssertionInfo info, boolean[] actual, boolean[] sequence)
          Verifies that the given array contains the given sequence of values, without any other values between them.
 void ByteArrays.assertContainsSequence(AssertionInfo info, byte[] actual, byte[] sequence)
          Verifies that the given array contains the given sequence of values, without any other values between them.
 void CharArrays.assertContainsSequence(AssertionInfo info, char[] actual, char[] sequence)
          Verifies that the given array contains the given sequence of values, without any other values between them.
 void DoubleArrays.assertContainsSequence(AssertionInfo info, double[] actual, double[] sequence)
          Verifies that the given array contains the given sequence of values, without any other values between them.
 void FloatArrays.assertContainsSequence(AssertionInfo info, float[] actual, float[] sequence)
          Verifies that the given array contains the given sequence of values, without any other values between them.
 void IntArrays.assertContainsSequence(AssertionInfo info, int[] actual, int[] sequence)
          Verifies that the given array contains the given sequence of values, without any other values between them.
 void Iterables.assertContainsSequence(AssertionInfo info, Iterable<?> actual, Object[] sequence)
          Verifies that the given Iterable contains the given sequence of objects, without any other objects between them.
 void LongArrays.assertContainsSequence(AssertionInfo info, long[] actual, long[] sequence)
          Verifies that the given array contains the given sequence of values, without any other values between them.
 void ObjectArrays.assertContainsSequence(AssertionInfo info, Object[] actual, Object[] sequence)
          Verifies that the given array contains the given sequence of objects, without any other objects between them.
 void ShortArrays.assertContainsSequence(AssertionInfo info, short[] actual, short[] sequence)
          Verifies that the given array contains the given sequence of values, without any other values between them.
 void BooleanArrays.assertDoesNotContain(AssertionInfo info, boolean[] actual, boolean[] values)
          Asserts that the given array does not contain the given values.
 void BooleanArrays.assertDoesNotContain(AssertionInfo info, boolean[] actual, boolean value, Index index)
          Verifies that the given array does not contain the given value at the given index.
 void ByteArrays.assertDoesNotContain(AssertionInfo info, byte[] actual, byte[] values)
          Asserts that the given array does not contain the given values.
 void ByteArrays.assertDoesNotContain(AssertionInfo info, byte[] actual, byte value, Index index)
          Verifies that the given array does not contain the given value at the given index.
 void CharArrays.assertDoesNotContain(AssertionInfo info, char[] actual, char[] values)
          Asserts that the given array does not contain the given values.
 void CharArrays.assertDoesNotContain(AssertionInfo info, char[] actual, char value, Index index)
          Verifies that the given array does not contain the given value at the given index.
 void DoubleArrays.assertDoesNotContain(AssertionInfo info, double[] actual, double[] values)
          Asserts that the given array does not contain the given values.
 void DoubleArrays.assertDoesNotContain(AssertionInfo info, double[] actual, double value, Index index)
          Verifies that the given array does not contain the given value at the given index.
 void FloatArrays.assertDoesNotContain(AssertionInfo info, float[] actual, float[] values)
          Asserts that the given array does not contain the given values.
 void FloatArrays.assertDoesNotContain(AssertionInfo info, float[] actual, float value, Index index)
          Verifies that the given array does not contain the given value at the given index.
 void IntArrays.assertDoesNotContain(AssertionInfo info, int[] actual, int[] values)
          Asserts that the given array does not contain the given values.
 void IntArrays.assertDoesNotContain(AssertionInfo info, int[] actual, int value, Index index)
          Verifies that the given array does not contain the given value at the given index.
 void Iterables.assertDoesNotContain(AssertionInfo info, Iterable<?> actual, Object[] values)
          Asserts that the 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.
 void Maps.assertDoesNotContain(AssertionInfo info, Map<?,?> actual, MapEntry[] 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.
 void Strings.assertDoesNotContain(AssertionInfo info, String actual, String sequence)
          Verifies that the given String does not contain the given sequence.
 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 Files.assertDoesNotExist(AssertionInfo info, File actual)
          Asserts that the given file does not exist.
<T> void
Conditions.assertDoesNotHave(AssertionInfo info, T actual, Condition<T> condition)
          Asserts that the actual value does not satisfy the given Condition.
 void BooleanArrays.assertDoesNotHaveDuplicates(AssertionInfo info, boolean[] actual)
          Asserts that the given array does not have duplicate values.
 void ByteArrays.assertDoesNotHaveDuplicates(AssertionInfo info, byte[] actual)
          Asserts that the given array does not have duplicate values.
 void CharArrays.assertDoesNotHaveDuplicates(AssertionInfo info, char[] actual)
          Asserts that the given array does not have duplicate values.
 void DoubleArrays.assertDoesNotHaveDuplicates(AssertionInfo info, double[] actual)
          Asserts that the given array does not have duplicate values.
 void FloatArrays.assertDoesNotHaveDuplicates(AssertionInfo info, float[] actual)
          Asserts that the given array does not have duplicate values.
 void IntArrays.assertDoesNotHaveDuplicates(AssertionInfo info, int[] actual)
          Asserts that the given array does not have duplicate values.
 void Iterables.assertDoesNotHaveDuplicates(AssertionInfo info, Iterable<?> actual)
          Asserts that the 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 Strings.assertDoesNotMatch(AssertionInfo info, String actual, Pattern pattern)
          Verifies that the given String does not match the given regular expression.
 void Strings.assertDoesNotMatch(AssertionInfo info, String actual, String regex)
          Verifies that the given String does not match the given regular expression.
<E> void
Iterables.assertDoNotHave(AssertionInfo info, Iterable<?> actual, Condition<E> condition)
          Assert that each element of given Iterable not satisfies the given condition.
<E> void
ObjectArrays.assertDoNotHave(AssertionInfo info, Object[] actual, Condition<E> condition)
          Assert that each element of given array not satisfies the given condition.
<E> void
Iterables.assertDoNotHaveAtLeast(AssertionInfo info, Iterable<?> actual, int times, Condition<E> condition)
          An alias method of Iterables.assertAreNotAtLeast(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
ObjectArrays.assertDoNotHaveAtLeast(AssertionInfo info, Object[] actual, int times, Condition<E> condition)
          An alias method of ObjectArrays.assertAreNotAtLeast(AssertionInfo, Object[], int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
Iterables.assertDoNotHaveAtMost(AssertionInfo info, Iterable<?> actual, int times, Condition<E> condition)
          An alias method of Iterables.assertAreNotAtMost(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
ObjectArrays.assertDoNotHaveAtMost(AssertionInfo info, Object[] actual, int times, Condition<E> condition)
          An alias method of ObjectArrays.assertAreNotAtMost(AssertionInfo, Object[], int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
Iterables.assertDoNotHaveExactly(AssertionInfo info, Iterable<?> actual, int times, Condition<E> condition)
          An alias method of Iterables.assertAreNotExactly(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
ObjectArrays.assertDoNotHaveExactly(AssertionInfo info, Object[] actual, int times, Condition<E> condition)
          An alias method of ObjectArrays.assertAreNotExactly(AssertionInfo, Object[], int, Condition) to provide a richer fluent api (same logic, only error message differs).
 void BooleanArrays.assertEmpty(AssertionInfo info, boolean[] actual)
          Asserts that the given array is empty.
 void ByteArrays.assertEmpty(AssertionInfo info, byte[] actual)
          Asserts that the given array is empty.
 void CharArrays.assertEmpty(AssertionInfo info, char[] actual)
          Asserts that the given array is empty.
 void DoubleArrays.assertEmpty(AssertionInfo info, double[] actual)
          Asserts that the given array is empty.
 void FloatArrays.assertEmpty(AssertionInfo info, float[] actual)
          Asserts that the given array is empty.
 void IntArrays.assertEmpty(AssertionInfo info, int[] actual)
          Asserts that the given array is empty.
 void Iterables.assertEmpty(AssertionInfo info, Iterable<?> actual)
          Asserts that the 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 Strings.assertEmpty(AssertionInfo info, String actual)
          Asserts that the given String is empty.
 void BooleanArrays.assertEndsWith(AssertionInfo info, boolean[] actual, boolean[] sequence)
          Verifies that the given array ends with the given sequence of values, without any other values between them.
 void ByteArrays.assertEndsWith(AssertionInfo info, byte[] actual, byte[] sequence)
          Verifies that the given array ends with the given sequence of values, without any other values between them.
 void CharArrays.assertEndsWith(AssertionInfo info, char[] actual, char[] sequence)
          Verifies that the given array ends with the given sequence of values, without any other values between them.
 void DoubleArrays.assertEndsWith(AssertionInfo info, double[] actual, double[] sequence)
          Verifies that the given array ends with the given sequence of values, without any other values between them.
 void FloatArrays.assertEndsWith(AssertionInfo info, float[] actual, float[] sequence)
          Verifies that the given array ends with the given sequence of values, without any other values between them.
 void IntArrays.assertEndsWith(AssertionInfo info, int[] actual, int[] sequence)
          Verifies that the given array ends with the given sequence of values, without any other values between them.
 void Iterables.assertEndsWith(AssertionInfo info, Iterable<?> actual, Object[] sequence)
          Verifies that the given Iterable ends with the given sequence of objects, without any other objects between them.
 void LongArrays.assertEndsWith(AssertionInfo info, long[] actual, long[] sequence)
          Verifies that the given array ends with the given sequence of values, without any other values between them.
 void ObjectArrays.assertEndsWith(AssertionInfo info, Object[] actual, Object[] sequence)
          Verifies that the given array ends with the given sequence of objects, without any other objects between them.
 void ShortArrays.assertEndsWith(AssertionInfo info, short[] actual, short[] sequence)
          Verifies that the given array ends with the given sequence of values, without any other values between them.
 void Strings.assertEndsWith(AssertionInfo info, String actual, String suffix)
          Verifies that the given String ends with the given suffix.
 void Booleans.assertEqual(AssertionInfo info, Boolean actual, boolean expected)
          Asserts that two booleans are equal.
 void Images.assertEqual(AssertionInfo info, BufferedImage actual, BufferedImage expected)
          Asserts that two images are equal.
 void Images.assertEqual(AssertionInfo info, BufferedImage actual, BufferedImage expected, Offset<Integer> offset)
          Asserts that two images are equal.
 void Doubles.assertEqual(AssertionInfo info, Double actual, Double expected, Offset<Double> offset)
          Verifies that two floats are equal within a positive offset.
 void Floats.assertEqual(AssertionInfo info, Float actual, Float expected, Offset<Float> offset)
          Verifies that two floats are equal within a positive offset.
 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<T>>
void
Comparables.assertEqualByComparison(AssertionInfo info, T actual, T expected)
          Asserts that two Comparables are equal by invoking Comparable.compareTo(Object).
 void Files.assertEqualContent(AssertionInfo info, File actual, File expected)
          Asserts that the given files have equal content.
 void InputStreams.assertEqualContent(AssertionInfo info, InputStream actual, InputStream expected)
          Asserts that the given InputStreams have equal content.
 void Strings.assertEqualsIgnoringCase(AssertionInfo info, String actual, String expected)
          Verifies that two Strings are equal, ignoring case considerations.
 void Files.assertExists(AssertionInfo info, File actual)
          Asserts that the given file exists, regardless it's a file or directory.
<T extends Comparable<T>>
void
Comparables.assertGreaterThan(AssertionInfo info, T actual, T other)
          Asserts that the actual value is greater than the other one.
<T extends Comparable<T>>
void
Comparables.assertGreaterThanOrEqualTo(AssertionInfo info, T actual, T other)
          Asserts that the actual value is greater than or equal to the other one.
<T> void
Conditions.assertHas(AssertionInfo info, T actual, Condition<T> condition)
          Asserts that the actual value satisfies the given Condition.
 void Throwables.assertHasMessage(AssertionInfo info, Throwable actual, String message)
          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.assertHasMessageStartingWith(AssertionInfo info, Throwable actual, String description)
          Asserts that the message of the actual Throwable starts with the given description.
 void Throwables.assertHasNoCause(AssertionInfo info, Throwable actual)
          Asserts that the actual Throwable does not have a cause.
 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 Images.assertHasSize(AssertionInfo info, BufferedImage actual, Dimension size)
          Asserts that the size of the given image is equal to the given size.
 void ByteArrays.assertHasSize(AssertionInfo info, byte[] actual, int expectedSize)
          Asserts that the number of elements in the given array is equal to the expected one.
 void CharArrays.assertHasSize(AssertionInfo info, char[] actual, int expectedSize)
          Asserts that the number of elements in the given array is equal to the expected one.
 void DoubleArrays.assertHasSize(AssertionInfo info, double[] actual, int expectedSize)
          Asserts that the number of elements in the given array is equal to the expected one.
 void FloatArrays.assertHasSize(AssertionInfo info, float[] actual, int expectedSize)
          Asserts that the number of elements in the given array is equal to the expected one.
 void IntArrays.assertHasSize(AssertionInfo info, int[] actual, int expectedSize)
          Asserts that the number of elements in the given array is equal to the expected one.
 void Iterables.assertHasSize(AssertionInfo info, Iterable<?> actual, int expectedSize)
          Asserts that the number of elements in the given Iterable is equal to the expected one.
 void LongArrays.assertHasSize(AssertionInfo info, long[] actual, int expectedSize)
          Asserts that the number of elements in the given array is equal to the expected one.
 void Maps.assertHasSize(AssertionInfo info, Map<?,?> actual, int expectedSize)
          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 Strings.assertHasSize(AssertionInfo info, String actual, int expectedSize)
          Asserts that the size of the given String is equal to the expected one.
<E> void
Iterables.assertHave(AssertionInfo info, Iterable<?> actual, Condition<E> condition)
          Assert that each element of given Iterable satisfies the given condition.
<E> void
ObjectArrays.assertHave(AssertionInfo info, Object[] actual, Condition<E> condition)
          Assert that each element of given array satisfies the given condition.
<E> void
Iterables.assertHaveAtLeast(AssertionInfo info, Iterable<?> actual, int times, Condition<E> condition)
          An alias method of Iterables.assertAreAtLeast(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
ObjectArrays.assertHaveAtLeast(AssertionInfo info, Object[] actual, int times, Condition<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
Iterables.assertHaveAtMost(AssertionInfo info, Iterable<?> actual, int times, Condition<E> condition)
          An alias method of Iterables.assertAreAtMost(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
ObjectArrays.assertHaveAtMost(AssertionInfo info, Object[] actual, int times, Condition<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
Iterables.assertHaveExactly(AssertionInfo info, Iterable<?> actual, int times, Condition<E> condition)
          An alias method of Iterables.assertAreExactly(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
ObjectArrays.assertHaveExactly(AssertionInfo info, Object[] actual, int times, Condition<E> condition)
          An alias method of ObjectArrays.assertAreExactly(AssertionInfo, Object[], int, Condition) to provide a richer fluent api (same logic, only error message differs).
<T> void
Conditions.assertIs(AssertionInfo info, T actual, Condition<T> condition)
          Asserts that the actual value satisfies the given Condition.
 void Files.assertIsAbsolute(AssertionInfo info, File actual)
          Asserts that the given file is an absolute path.
 void Dates.assertIsAfter(AssertionInfo info, Date actual, Date other)
          Verifies that the 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 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.
 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.
 void Files.assertIsDirectory(AssertionInfo info, File actual)
          Asserts that the given file is an existing directory.
 void Throwables.assertIsExactlyInstanceOf(AssertionInfo info, Throwable actual, Class<? extends Throwable> type)
          Asserts that the actual Throwable type is an the same as the given type.
 void Files.assertIsFile(AssertionInfo info, File actual)
          Asserts that the given file is an existing file.
 void Objects.assertIsIn(AssertionInfo info, Object actual, Collection<?> 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 chronologically in the same hour (and thus in the same day of month, month and year).
 void Dates.assertIsInSameMinuteAs(AssertionInfo info, Date actual, Date other)
          Verifies that actual and given Date are chronologically in the same minute (and thus in the same hour, day of month, month and year).
 void Dates.assertIsInSameMonthAs(AssertionInfo info, 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 chronologically in the same second (and thus in the same minute, hour, day of month, month and year).
 void Dates.assertIsInSameYearAs(AssertionInfo info, Date actual, Date other)
          Verifies that actual and 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 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.
 void Numbers.assertIsNegative(AssertionInfo info, NUMBER actual)
          Asserts that the actual value is negative.
<T> void
Conditions.assertIsNot(AssertionInfo info, T actual, Condition<T> condition)
          Asserts that the actual value does not satisfy the given Condition.
 void Dates.assertIsNotBetween(AssertionInfo info, Date actual, Date start, Date end, boolean inclusiveStart, boolean inclusiveEnd)
          Verifies that the actual Date is not in start:end period..
 void Objects.assertIsNotIn(AssertionInfo info, Object actual, Collection<?> values)
          Asserts that the given object is not present in the given collection.
 void Objects.assertIsNotIn(AssertionInfo info, Object actual, Object[] values)
          Asserts that the given object is not present in the given array.
 void RealNumbers.assertIsNotNaN(AssertionInfo info, NUMBER actual)
          Verifies that the actual value is not equal to NaN.
 void Numbers.assertIsNotZero(AssertionInfo info, NUMBER actual)
          Asserts that the actual value is not equal to zero.
 void Numbers.assertIsPositive(AssertionInfo info, NUMBER actual)
          Asserts that the actual value is positive.
 void Files.assertIsRelative(AssertionInfo info, File actual)
          Asserts that the given file is a relative path.
 void BooleanArrays.assertIsSorted(AssertionInfo info, boolean[] actual)
          Concrete implementation 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 into 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<? extends Boolean> comparator)
          Concrete implementation of ArraySortedAssert.isSortedAccordingTo(Comparator).
 void ByteArrays.assertIsSortedAccordingToComparator(AssertionInfo info, byte[] actual, Comparator<? extends Byte> comparator)
          Concrete implementation of ArraySortedAssert.isSortedAccordingTo(Comparator).
 void CharArrays.assertIsSortedAccordingToComparator(AssertionInfo info, char[] actual, Comparator<? extends Character> comparator)
          Concrete implementation of ArraySortedAssert.isSortedAccordingTo(Comparator).
 void DoubleArrays.assertIsSortedAccordingToComparator(AssertionInfo info, double[] actual, Comparator<? extends Double> comparator)
          Concrete implementation of ArraySortedAssert.isSortedAccordingTo(Comparator).
 void FloatArrays.assertIsSortedAccordingToComparator(AssertionInfo info, float[] actual, Comparator<? extends Float> comparator)
          Concrete implementation of ArraySortedAssert.isSortedAccordingTo(Comparator).
 void IntArrays.assertIsSortedAccordingToComparator(AssertionInfo info, int[] actual, Comparator<? extends Integer> comparator)
          Concrete implementation of ArraySortedAssert.isSortedAccordingTo(Comparator).
 void Lists.assertIsSortedAccordingToComparator(AssertionInfo info, List<?> actual, Comparator<? extends Object> comparator)
          Verifies that the actual list is sorted according to the given comparator.
 void LongArrays.assertIsSortedAccordingToComparator(AssertionInfo info, long[] actual, Comparator<? extends Long> comparator)
          Concrete implementation of ArraySortedAssert.isSortedAccordingTo(Comparator).
 void ObjectArrays.assertIsSortedAccordingToComparator(AssertionInfo info, Object[] actual, Comparator<? extends Object> comparator)
          Concrete implementation of ArraySortedAssert.isSortedAccordingTo(Comparator).
 void ShortArrays.assertIsSortedAccordingToComparator(AssertionInfo info, short[] actual, Comparator<? extends Short> comparator)
          Concrete implementation of ArraySortedAssert.isSortedAccordingTo(Comparator).
 void Iterables.assertIsSubsetOf(AssertionInfo info, Iterable<?> actual, Iterable<?> values)
          Verifies that the actual Iterable is a subset of values Iterable.
 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. we don't check hours).
 void Dates.assertIsWithinDayOfMonth(AssertionInfo info, Date actual, int dayOfMonth)
          Verifies that the actual Date day of month is equal to the given day of month.
 void Dates.assertIsWithinDayOfWeek(AssertionInfo info, Date actual, int dayOfWeek)
          Verifies that the actual Date day of week is equal to the given day of week.
 void Dates.assertIsWithinHourOfDay(AssertionInfo info, Date actual, int hourOfDay)
          Verifies that the actual Date hour od day is equal to the given hour of day (24-hour clock).
 void Dates.assertIsWithinMillisecond(AssertionInfo info, Date actual, int millisecond)
          Verifies that the actual Date millisecond is equal to the given millisecond.
 void Dates.assertIsWithinMinute(AssertionInfo info, Date actual, int minute)
          Verifies that the actual Date minute is equal to the given minute.
 void Dates.assertIsWithinMonth(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 Dates.assertIsWithinSecond(AssertionInfo info, Date actual, int second)
          Verifies that the actual Date second is equal to the given second.
 void Dates.assertIsWithinYear(AssertionInfo info, Date actual, int year)
          Verifies that the actual Date year is equal to the given year.
 void Numbers.assertIsZero(AssertionInfo info, NUMBER actual)
          Asserts that the actual value is equal to zero.
<T extends Comparable<T>>
void
Comparables.assertLessThan(AssertionInfo info, T actual, T other)
          Asserts that the actual value is less than the other one.
<T extends Comparable<T>>
void
Comparables.assertLessThanOrEqualTo(AssertionInfo info, T actual, T other)
          Asserts that the actual value is less than or equal to the other one.
 void Characters.assertLowerCase(AssertionInfo info, Character actual)
          Asserts that the actual value is a lowercase character.
 void Strings.assertMatches(AssertionInfo info, String actual, Pattern pattern)
          Verifies that the given String matches the given regular expression.
 void Strings.assertMatches(AssertionInfo info, String actual, String regex)
          Verifies that the given String matches the given regular expression.
 void BooleanArrays.assertNotEmpty(AssertionInfo info, boolean[] actual)
          Asserts that the given array is not empty.
 void ByteArrays.assertNotEmpty(AssertionInfo info, byte[] actual)
          Asserts that the given array is not empty.
 void CharArrays.assertNotEmpty(AssertionInfo info, char[] actual)
          Asserts that the given array is not empty.
 void DoubleArrays.assertNotEmpty(AssertionInfo info, double[] actual)
          Asserts that the given array is not empty.
 void FloatArrays.assertNotEmpty(AssertionInfo info, float[] actual)
          Asserts that the given array is not empty.
 void IntArrays.assertNotEmpty(AssertionInfo info, int[] actual)
          Asserts that the given array is not empty.
 void Iterables.assertNotEmpty(AssertionInfo info, 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 Strings.assertNotEmpty(AssertionInfo info, String actual)
          Asserts that the given String is not empty.
 void Booleans.assertNotEqual(AssertionInfo info, Boolean actual, boolean other)
          Asserts that two longs are not equal.
 void Images.assertNotEqual(AssertionInfo info, BufferedImage actual, BufferedImage other)
          Asserts that two images 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<T>>
void
Comparables.assertNotEqualByComparison(AssertionInfo info, T actual, T other)
          Asserts that two Comparables are not equal by invoking Comparable.compareTo(Object).
 void Objects.assertNotNull(AssertionInfo info, Object actual)
          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 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 Iterable 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 Strings.assertNullOrEmpty(AssertionInfo info, String actual)
          Asserts that the given String is null or empty.
 void Objects.assertSame(AssertionInfo info, Object actual, Object expected)
          Asserts that two objects refer to the same object.
 void BooleanArrays.assertStartsWith(AssertionInfo info, boolean[] actual, boolean[] sequence)
          Verifies that the given array starts with the given sequence of values, without any other values between them.
 void ByteArrays.assertStartsWith(AssertionInfo info, byte[] actual, byte[] sequence)
          Verifies that the given array starts with the given sequence of values, without any other values between them.
 void CharArrays.assertStartsWith(AssertionInfo info, char[] actual, char[] sequence)
          Verifies that the given array starts with the given sequence of values, without any other values between them.
 void DoubleArrays.assertStartsWith(AssertionInfo info, double[] actual, double[] sequence)
          Verifies that the given array starts with the given sequence of values, without any other values between them.
 void FloatArrays.assertStartsWith(AssertionInfo info, float[] actual, float[] sequence)
          Verifies that the given array starts with the given sequence of values, without any other values between them.
 void IntArrays.assertStartsWith(AssertionInfo info, int[] actual, int[] sequence)
          Verifies that the given array starts with the given sequence of values, without any other values between them.
 void Iterables.assertStartsWith(AssertionInfo info, Iterable<?> actual, Object[] sequence)
          Verifies that the 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 ShortArrays.assertStartsWith(AssertionInfo info, short[] actual, short[] sequence)
          Verifies that the given array starts with the given sequence of values, without any other values between them.
 void Strings.assertStartsWith(AssertionInfo info, String actual, String prefix)
          Verifies that the given String starts with the given prefix.
 void Characters.assertUpperCase(AssertionInfo info, Character actual)
          Asserts that the actual value is a uppercase character.
 AssertionError Failures.failure(AssertionInfo info, AssertionErrorFactory factory)
          Creates a AssertionError following this pattern: creates a AssertionError using overridingErrorMessage() as the error message if such value is not null, or uses the given AssertionErrorFactory to create an AssertionError, prepending the value of description() to the error message
 AssertionError Failures.failure(AssertionInfo info, ErrorMessageFactory message)
          Creates a AssertionError following this pattern: creates a AssertionError using overridingErrorMessage() as the error message if such value is not null, or uses the given ErrorMessageFactory to create the detail message of the AssertionError, prepending the value of description() to the error message
 



Copyright © 2007-2012 FEST (Fixtures for Easy Software Testing). All Rights Reserved.