public interface WithAssertions
| Modifier and Type | Method and Description |
|---|---|
default <T> Condition<T> |
allOf(Condition<? super T>... conditions)
Creates a new
|
default <T> Condition<T> |
allOf(Iterable<? extends Condition<? super T>> conditions)
Creates a new
|
default <T> Condition<T> |
anyOf(Condition<? super T>... conditions)
Only delegate to
AnyOf.anyOf(Condition...) so that Assertions offers a full feature entry point to all
AssertJ features (but you can use AnyOf if you prefer). |
default <T> Condition<T> |
anyOf(Iterable<? extends Condition<? super T>> conditions)
Creates a new
|
default <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
assertThat(ACTUAL actual,
Class<ELEMENT_ASSERT> assertClass)
Creates a new instance of
Iterable element
in order to perform assertions on it. |
default <T> T |
assertThat(AssertProvider<T> component)
Delegates the creation of the
Assert to the AssertProvider.assertThat() of the given component. |
default AtomicBooleanAssert |
assertThat(AtomicBoolean actual)
Create assertion for
AtomicBoolean. |
default AtomicIntegerAssert |
assertThat(AtomicInteger actual)
Create assertion for
AtomicInteger. |
default AtomicIntegerArrayAssert |
assertThat(AtomicIntegerArray actual)
Create int[] assertion for
AtomicIntegerArray. |
default <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT> |
assertThat(AtomicIntegerFieldUpdater<OBJECT> actual)
Create assertion for
AtomicIntegerFieldUpdater. |
default AtomicLongAssert |
assertThat(AtomicLong actual)
Create assertion for
AtomicLong. |
default AtomicLongArrayAssert |
assertThat(AtomicLongArray actual)
Create assertion for
AtomicLongArray. |
default <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT> |
assertThat(AtomicLongFieldUpdater<OBJECT> actual)
Create assertion for
AtomicLongFieldUpdater. |
default <VALUE> AtomicMarkableReferenceAssert<VALUE> |
assertThat(AtomicMarkableReference<VALUE> actual)
Create assertion for
AtomicMarkableReference. |
default <VALUE> AtomicReferenceAssert<VALUE> |
assertThat(AtomicReference<VALUE> actual)
Create assertion for
AtomicReference. |
default <ELEMENT> AtomicReferenceArrayAssert<ELEMENT> |
assertThat(AtomicReferenceArray<ELEMENT> actual)
Create assertion for
AtomicReferenceArray. |
default <FIELD,OBJECT> |
assertThat(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)
Create assertion for
AtomicReferenceFieldUpdater. |
default <VALUE> AtomicStampedReferenceAssert<VALUE> |
assertThat(AtomicStampedReference<VALUE> actual)
Create assertion for
AtomicStampedReference. |
default AbstractBigDecimalAssert<?> |
assertThat(BigDecimal actual)
Creates a new instance of
|
default AbstractBigIntegerAssert<?> |
assertThat(BigInteger actual)
Creates a new instance of
|
default AbstractBooleanAssert<?> |
assertThat(boolean actual)
Creates a new instance of
|
default AbstractBooleanAssert<?> |
assertThat(Boolean actual)
Creates a new instance of
|
default AbstractBooleanArrayAssert<?> |
assertThat(boolean[] actual)
Creates a new instance of
|
default AbstractByteAssert<?> |
assertThat(byte actual)
Creates a new instance of
|
default AbstractByteAssert<?> |
assertThat(Byte actual)
Creates a new instance of
|
default AbstractByteArrayAssert<?> |
assertThat(byte[] actual)
Creates a new instance of
|
default AbstractCharacterAssert<?> |
assertThat(char actual)
Creates a new instance of
|
default AbstractCharArrayAssert<?> |
assertThat(char[] actual)
Creates a new instance of
|
default AbstractCharacterAssert<?> |
assertThat(Character actual)
Creates a new instance of
|
default AbstractCharSequenceAssert<?,? extends CharSequence> |
assertThat(CharSequence actual)
Creates a new instance of
|
default ClassAssert |
assertThat(Class<?> actual)
Creates a new instance of
|
default <RESULT> CompletableFutureAssert<RESULT> |
assertThat(CompletableFuture<RESULT> future)
Create assertion for
CompletableFuture. |
default <RESULT> CompletableFutureAssert<RESULT> |
assertThat(CompletionStage<RESULT> completionStage)
Create assertion for
CompletionStage by converting it to a CompletableFuture and returning a CompletableFutureAssert. |
default AbstractDateAssert<?> |
assertThat(Date actual)
Creates a new instance of
|
default AbstractDoubleAssert<?> |
assertThat(double actual)
Creates a new instance of
|
default AbstractDoubleAssert<?> |
assertThat(Double actual)
Creates a new instance of
|
default AbstractDoubleArrayAssert<?> |
assertThat(double[] actual)
Creates a new instance of
|
default DoublePredicateAssert |
assertThat(DoublePredicate actual)
Create assertion for
DoublePredicate. |
default ListAssert<Double> |
assertThat(DoubleStream actual)
Creates a new instance of
DoubleStream. |
default AbstractFileAssert<?> |
assertThat(File actual)
Creates a new instance of
|
default AbstractFloatAssert<?> |
assertThat(float actual)
Creates a new instance of
|
default AbstractFloatAssert<?> |
assertThat(Float actual)
Creates a new instance of
|
default AbstractFloatArrayAssert<?> |
assertThat(float[] actual)
Creates a new instance of
|
default <RESULT> FutureAssert<RESULT> |
assertThat(Future<RESULT> actual)
Create assertion for
Future. |
default AbstractInputStreamAssert<?,? extends InputStream> |
assertThat(InputStream actual)
Creates a new instance of
|
default AbstractInstantAssert<?> |
assertThat(Instant actual)
Creates a new instance of
|
default AbstractIntegerAssert<?> |
assertThat(int actual)
Creates a new instance of
|
default AbstractIntArrayAssert<?> |
assertThat(int[] actual)
Creates a new instance of
|
default AbstractIntegerAssert<?> |
assertThat(Integer actual)
Creates a new instance of
|
default IntPredicateAssert |
assertThat(IntPredicate actual)
Create assertion for
IntPredicate. |
default ListAssert<Integer> |
assertThat(IntStream actual)
Creates a new instance of
IntStream. |
default <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
assertThat(Iterable<? extends ELEMENT> actual,
AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
Creates a new instance of
Iterable element
in order to perform assertions on it. |
default <T> IterableAssert<T> |
assertThat(Iterable<? extends T> actual)
Creates a new instance of
|
default <T> IteratorAssert<T> |
assertThat(Iterator<? extends T> actual)
Creates a new instance of
|
default <ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
assertThat(List<? extends ELEMENT> actual,
AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
Creates a new instance of
List element
in order to perform assertions on it. |
default <ELEMENT,ACTUAL extends List<? extends ELEMENT>,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
assertThat(List<? extends ELEMENT> actual,
Class<ELEMENT_ASSERT> assertClass)
Creates a new instance of
List element
in order to perform assertions on it. |
default <T> ListAssert<T> |
assertThat(List<? extends T> actual)
Creates a new instance of
|
default AbstractLocalDateAssert<?> |
assertThat(LocalDate localDate)
Creates a new instance of
|
default AbstractLocalDateTimeAssert<?> |
assertThat(LocalDateTime localDateTime)
Creates a new instance of
|
default AbstractLocalTimeAssert<?> |
assertThat(LocalTime localTime)
Creates a new instance of
|
default AbstractLongAssert<?> |
assertThat(long actual)
Creates a new instance of
|
default AbstractLongAssert<?> |
assertThat(Long actual)
Creates a new instance of
|
default AbstractLongArrayAssert<?> |
assertThat(long[] actual)
Creates a new instance of
|
default LongPredicateAssert |
assertThat(LongPredicate actual)
Create assertion for
LongPredicate. |
default ListAssert<Long> |
assertThat(LongStream actual)
Creates a new instance of
LongStream. |
default <K,V> MapAssert<K,V> |
assertThat(Map<K,V> actual)
Creates a new instance of
|
default AbstractOffsetDateTimeAssert<?> |
assertThat(OffsetDateTime offsetDateTime)
Creates a new instance of
|
default AbstractOffsetTimeAssert<?> |
assertThat(OffsetTime offsetTime)
Creates a new instance of
|
default <VALUE> OptionalAssert<VALUE> |
assertThat(Optional<VALUE> optional)
Create assertion for
Optional. |
default OptionalDoubleAssert |
assertThat(OptionalDouble optional)
Create assertion for
OptionalDouble. |
default OptionalIntAssert |
assertThat(OptionalInt optional)
Create assertion for
OptionalInt. |
default OptionalLongAssert |
assertThat(OptionalLong optional)
Create assertion for
OptionalLong. |
default AbstractPathAssert<?> |
assertThat(Path actual)
Creates a new instance of
PathAssert |
default <T> PredicateAssert<T> |
assertThat(Predicate<T> actual)
Create assertion for
Predicate. |
default AbstractShortAssert<?> |
assertThat(short actual)
Creates a new instance of
|
default AbstractShortAssert<?> |
assertThat(Short actual)
Creates a new instance of
|
default AbstractShortArrayAssert<?> |
assertThat(short[] actual)
Creates a new instance of
|
default <ELEMENT> ListAssert<ELEMENT> |
assertThat(Stream<? extends ELEMENT> actual)
Creates a new instance of
Stream. |
default AbstractStringAssert<?> |
assertThat(String actual)
Creates a new instance of
|
default AbstractCharSequenceAssert<?,? extends CharSequence> |
assertThat(StringBuffer actual)
Creates a new instance of
StringBuffer. |
default AbstractCharSequenceAssert<?,? extends CharSequence> |
assertThat(StringBuilder actual)
Creates a new instance of
StringBuilder. |
default <T> ObjectAssert<T> |
assertThat(T actual)
Creates a new instance of
|
default <T extends Comparable<? super T>> |
assertThat(T actual)
Creates a new instance of
|
default <T extends AssertDelegateTarget> |
assertThat(T assertion)
Returns the given assertion.
|
default <T> ObjectArrayAssert<T> |
assertThat(T[] actual)
Creates a new instance of
|
default AbstractThrowableAssert<?,? extends Throwable> |
assertThat(Throwable actual)
Creates a new instance of
|
default AbstractUriAssert<?> |
assertThat(URI actual)
Creates a new instance of
|
default AbstractUrlAssert<?> |
assertThat(URL actual)
Creates a new instance of
|
default AbstractZonedDateTimeAssert<?> |
assertThat(ZonedDateTime actual)
Creates a new instance of
|
default AbstractThrowableAssert<?,? extends Throwable> |
assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)
Allows to capture and then assert on a
Throwable more easily when used with Java 8 lambdas. |
default <T extends Throwable> |
assertThatExceptionOfType(Class<? extends T> exceptionType)
Entry point to check that an exception of type T is thrown by a given
throwingCallable
which allows to chain assertions on the thrown exception. |
default ThrowableTypeAssert<IllegalArgumentException> |
assertThatIllegalArgumentException()
Alias for
assertThatExceptionOfType(Class) for IllegalArgumentException. |
default ThrowableTypeAssert<IllegalStateException> |
assertThatIllegalStateException()
Alias for
assertThatExceptionOfType(Class) for IllegalStateException. |
default ThrowableTypeAssert<IOException> |
assertThatIOException()
Alias for
assertThatExceptionOfType(Class) for IOException. |
default ThrowableTypeAssert<NullPointerException> |
assertThatNullPointerException()
Alias for
assertThatExceptionOfType(Class) for NullPointerException. |
default <T> ObjectAssert<T> |
assertThatObject(T actual)
Creates a new instance of
|
default AbstractThrowableAssert<?,? extends Throwable> |
assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Allows to capture and then assert on a
Throwable (easier done with lambdas). |
default AbstractThrowableAssert<?,? extends Throwable> |
assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable,
String description,
Object... args)
Allows to capture and then assert on a
Throwable like assertThatThrownBy(ThrowingCallable) but this method
let you set the assertion description the same way you do with as(String, Object...). |
default Index |
atIndex(int index)
Only delegate to
Index.atIndex(int) so that Assertions offers a full feature entry point to all AssertJ
features (but you can use Index if you prefer). |
default Offset<BigDecimal> |
byLessThan(BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
default Offset<BigInteger> |
byLessThan(BigInteger value)
Assertions entry point for BigInteger
Offset to use with isCloseTo assertions. |
default Offset<Byte> |
byLessThan(Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
default Offset<Double> |
byLessThan(Double value)
Alias for
offset(Double) to use with isCloseTo assertions. |
default Offset<Float> |
byLessThan(Float value)
Alias for
offset(Float) to use with isCloseTo assertions. |
default Offset<Integer> |
byLessThan(Integer value)
Assertions entry point for Integer
Offset to use with isCloseTo assertions. |
default Offset<Long> |
byLessThan(Long value)
Assertions entry point for Long
Offset to use with isCloseTo assertions. |
default TemporalUnitOffset |
byLessThan(long value,
TemporalUnit unit)
Assertions entry point for
TemporalUnitOffset with strict less than condition
to use with isCloseTo temporal assertions. |
default Offset<Short> |
byLessThan(Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
default Throwable |
catchThrowable(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Allows to catch an
Throwable more easily when used with Java 8 lambdas. |
default <THROWABLE extends Throwable> |
catchThrowableOfType(ThrowableAssert.ThrowingCallable shouldRaiseThrowable,
Class<THROWABLE> type)
Allows catching a
Throwable of a specific type. |
default String |
contentOf(File file)
Loads the text content of a file with the default character set, so that it can be passed to
assertThat(String). |
default String |
contentOf(File file,
Charset charset)
Loads the text content of a file, so that it can be passed to
assertThat(String). |
default String |
contentOf(File file,
String charsetName)
Loads the text content of a file, so that it can be passed to
assertThat(String). |
default String |
contentOf(URL url)
Loads the text content of a URL with the default character set, so that it can be passed to
assertThat(String). |
default String |
contentOf(URL url,
Charset charset)
Loads the text content of a URL, so that it can be passed to
assertThat(String). |
default String |
contentOf(URL url,
String charsetName)
Loads the text content of a URL, so that it can be passed to
assertThat(String). |
default <T> DoesNotHave<T> |
doesNotHave(Condition<? super T> condition)
Creates a new
|
default <K,V> MapEntry<K,V> |
entry(K key,
V value)
Only delegate to
MapEntry.entry(Object, Object) so that Assertions offers a full feature entry point to
all
AssertJ features (but you can use MapEntry if you prefer). |
default Properties<Object> |
extractProperty(String propertyName)
Only delegate to
Properties.extractProperty(String) so that Assertions offers a full feature entry point
to
all AssertJ features (but you can use Properties if you prefer). |
default <T> Properties<T> |
extractProperty(String propertyName,
Class<T> propertyType)
Only delegate to
Properties.extractProperty(String) so that Assertions offers a full feature entry point
to
all AssertJ features (but you can use Properties if you prefer). |
default <T> T |
fail(String failureMessage)
Throws an
AssertionError with the given message. |
default <T> T |
fail(String failureMessage,
Object... args)
Throws an
AssertionError with the given message built as String.format(String, Object...). |
default <T> T |
fail(String failureMessage,
Throwable realCause)
Throws an
AssertionError with the given message and with the Throwable that caused the failure. |
default <T> T |
failBecauseExceptionWasNotThrown(Class<? extends Throwable> throwableClass)
Throws an
AssertionError with a message explaining that a Throwable of given class was expected to be thrown
but had not been. |
default <E> Filters<E> |
filter(E[] array)
Only delegate to
Filters.filter(Object[]) so that Assertions offers a full feature entry point to all
AssertJ features (but you can use Filters if you prefer). |
default <E> Filters<E> |
filter(Iterable<E> iterableToFilter)
Only delegate to
Filters.filter(Object[]) so that Assertions offers a full feature entry point to all
AssertJ features (but you can use Filters if you prefer). |
default <F,T> Function<F,T> |
from(Function<F,T> extractor)
A syntax sugar to write fluent assertion using
AbstractObjectAssert.returns(Object, Function). |
default InFilter |
in(Object... values)
Create a
FilterOperator to use in filteredOn(String, FilterOperation) to express a filter keeping all Iterable elements whose property/field
value matches one of the given values. |
default List<String> |
linesOf(File file)
Loads the text content of a file into a list of strings with the default charset, each string corresponding to a
line.
|
default List<String> |
linesOf(File file,
Charset charset)
Loads the text content of a file into a list of strings, each string corresponding to a line.
|
default List<String> |
linesOf(File file,
String charsetName)
Loads the text content of a file into a list of strings, each string corresponding to a line.
|
default List<String> |
linesOf(URL url)
Loads the text content of a URL into a list of strings with the default charset, each string corresponding to a
line.
|
default List<String> |
linesOf(URL url,
Charset charset)
Loads the text content of a URL into a list of strings, each string corresponding to a line.
|
default List<String> |
linesOf(URL url,
String charsetName)
Loads the text content of a URL into a list of strings, each string corresponding to a line.
|
default <T> Not<T> |
not(Condition<? super T> condition)
Creates a new
|
default NotFilter |
not(Object valueNotToMatch)
Create a
FilterOperator to use in filteredOn(String, FilterOperation) to express a filter keeping all Iterable elements whose property/field
value matches does not match the given value. |
default NotInFilter |
notIn(Object... valuesNotToMatch)
Create a
FilterOperator to use in filteredOn(String, FilterOperation) to express a filter keeping all Iterable elements whose property/field
value matches does not match any of the given values. |
default Offset<Double> |
offset(Double value)
Assertions entry point for double
Offset. |
default Offset<Float> |
offset(Float value)
Assertions entry point for float
Offset. |
default void |
registerCustomDateFormat(DateFormat userCustomDateFormat)
Add the given date format to the ones used to parse date String in String based Date assertions like
AbstractDateAssert.isEqualTo(String). |
default void |
registerCustomDateFormat(String userCustomDateFormatPattern)
Add the given date format to the ones used to parse date String in String based Date assertions like
AbstractDateAssert.isEqualTo(String). |
default <T> void |
registerFormatterForType(Class<T> type,
Function<T,String> formatter)
Assertions error messages uses a
Representation to format the different types involved, using this method
you can control the formatting of a given type by providing a specific formatter. |
default void |
setAllowComparingPrivateFields(boolean allowComparingPrivateFields)
Globally sets whether the use of private fields is allowed for comparison.
|
default void |
setAllowExtractingPrivateFields(boolean allowExtractingPrivateFields)
Globally sets whether
|
default void |
setExtractBareNamePropertyMethods(boolean barenamePropertyMethods)
Globally sets whether the extractor considers bare-named property methods like
String name(). |
default void |
setLenientDateParsing(boolean value)
Instead of using default strict date/time parsing, it is possible to use lenient parsing mode for default date
formats parser to interpret inputs that do not precisely match supported date formats (lenient parsing).
|
default void |
setMaxElementsForPrinting(int maxElementsForPrinting)
In error messages, sets the threshold for how many elements from one iterable/array/map will be included in the
in the description.
|
default void |
setMaxLengthForSingleLineDescription(int maxLengthForSingleLineDescription)
In error messages, sets the threshold when iterable/array formatting will on one line (if their String description
is less than this parameter) or it will be formatted with one element per line.
|
default void |
setRemoveAssertJRelatedElementsFromStackTrace(boolean removeAssertJRelatedElementsFromStackTrace)
Sets whether we remove elements related to AssertJ from assertion error stack trace.
|
default <T> T |
shouldHaveThrown(Class<? extends Throwable> throwableClass)
Throws an
AssertionError with a message explaining that a Throwable of given class was expected to be thrown
but had not been. |
default Tuple |
tuple(Object... values)
Utility method to build nicely a
Tuple when working with AbstractIterableAssert.extracting(String...) or
AbstractObjectArrayAssert.extracting(String...) |
default void |
useDefaultDateFormatsOnly()
Remove all registered custom date formats => use only the defaults date formats to parse string as date.
|
default void |
useDefaultRepresentation()
Fallback to use
StandardRepresentation to revert the effect of calling useRepresentation(Representation). |
default void |
useRepresentation(Representation customRepresentation)
Register a
Representation that will be used in all following assertions. |
default Offset<BigDecimal> |
within(BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
default Offset<BigInteger> |
within(BigInteger value)
Assertions entry point for BigInteger
Offset to use with isCloseTo assertions. |
default Offset<Byte> |
within(Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
default Offset<Double> |
within(Double value)
Alias for
offset(Double) to use with isCloseTo assertions. |
default Offset<Float> |
within(Float value)
Alias for
offset(Float) to use with isCloseTo assertions. |
default Offset<Integer> |
within(Integer value)
Assertions entry point for Integer
Offset to use with isCloseTo assertions. |
default Offset<Long> |
within(Long value)
Assertions entry point for Long
Offset to use with isCloseTo assertions. |
default TemporalUnitOffset |
within(long value,
TemporalUnit unit)
Assertions entry point for
TemporalUnitOffset with with less than or equal condition
to use with isCloseTo temporal assertions. |
default Offset<Short> |
within(Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
default Percentage |
withinPercentage(Double value)
Assertions entry point for Double
Percentage to use with isCloseTo assertions for
percentages. |
default Percentage |
withinPercentage(Integer value)
Assertions entry point for Integer
Percentage to use with isCloseTo assertions for
percentages. |
default Percentage |
withinPercentage(Long value)
Assertions entry point for Long
Percentage to use with isCloseTo assertions for
percentages. |
default Offset<Double> |
withPrecision(Double value)
Assertions entry point for double
Offset. |
default Offset<Float> |
withPrecision(Float value)
Assertions entry point for float
Offset. |
default Offset<Float> offset(Float value)
Offset.
Typical usage :
assertThat(8.2f).isCloseTo(8.0f, offset(0.2f));value - the allowed offsetOffset.default Offset<Double> offset(Double value)
Offset.
Typical usage :
assertThat(8.1).isEqualTo(8.0, offset(0.1));value - the allowed offsetOffset.default <K,V> MapEntry<K,V> entry(K key, V value)
MapEntry.entry(Object, Object) so that Assertions offers a full feature entry point to
all
AssertJ features (but you can use MapEntry if you prefer).
Typical usage is to call entry in MapAssert contains assertion, see examples below :
Map<Ring, TolkienCharacter> ringBearers = ... // init omitted
assertThat(ringBearers).contains(entry(oneRing, frodo), entry(nenya, galadriel));K - the type of keys in the map.V - the type of values in the map.key - the key of the entry to create.value - the value of the entry to create.MapEntry.default <T> T fail(String failureMessage)
AssertionError with the given message.T - dummy return value typefailureMessage - error message.AssertionError - with the given message.default <T> T fail(String failureMessage, Object... args)
AssertionError with the given message built as String.format(String, Object...).T - dummy return value typefailureMessage - error message.args - Arguments referenced by the format specifiers in the format string.AssertionError - with the given built message.default <T> T fail(String failureMessage, Throwable realCause)
AssertionError with the given message and with the Throwable that caused the failure.T - dummy return value typefailureMessage - the description of the failed assertion. It can be null.realCause - cause of the error.AssertionError - with the given message and with the Throwable that caused the failure.default <T> Not<T> not(Condition<? super T> condition)
NotT - the type of object the given condition accept.condition - the condition to inverse.default <T> Condition<T> allOf(Iterable<? extends Condition<? super T>> conditions)
AllOfT - the type of object the given condition accept.conditions - the conditions to evaluate.AnyOf.NullPointerException - if the given iterable is null.NullPointerException - if any of the elements in the given iterable is null.default <T> Condition<T> allOf(Condition<? super T>... conditions)
AllOfT - the type of object the given condition accept.conditions - the conditions to evaluate.AnyOf.NullPointerException - if the given array is null.NullPointerException - if any of the elements in the given array is null.default <T> ObjectArrayAssert<T> assertThat(T[] actual)
ObjectArrayAssertT - the actual's elements type.actual - the actual value.default <T extends AssertDelegateTarget> T assertThat(T assertion)
assertThat.
Consider for example the following MyButton and MyButtonAssert classes:
public class MyButton extends JButton {
private boolean blinking;
public boolean isBlinking() { return this.blinking; }
public void setBlinking(boolean blink) { this.blinking = blink; }
}
private static class MyButtonAssert implements AssertDelegateTarget {
private MyButton button;
MyButtonAssert(MyButton button) { this.button = button; }
void isBlinking() {
// standard assertion from core Assertions.assertThat
assertThat(button.isBlinking()).isTrue();
}
void isNotBlinking() {
// standard assertion from core Assertions.assertThat
assertThat(button.isBlinking()).isFalse();
}
}assertThat(buttonAssert).isBlinking();
instead of buttonAssert.isBlinking(); to have easier to read assertions:
@Test
public void AssertDelegateTarget_example() {
MyButton button = new MyButton();
MyButtonAssert buttonAssert = new MyButtonAssert(button);
// you can encapsulate MyButtonAssert assertions methods within assertThat
assertThat(buttonAssert).isNotBlinking(); // same as : buttonAssert.isNotBlinking();
button.setBlinking(true);
assertThat(buttonAssert).isBlinking(); // same as : buttonAssert.isBlinking();
}T - the generic type of the user-defined assert.assertion - the assertion to return.default <K,V> MapAssert<K,V> assertThat(Map<K,V> actual)
MapAssert
Returned type is MapAssert as it overrides method to annotate them with SafeVarargs avoiding
annoying warnings.
K - the type of keys in the map.V - the type of values in the map.actual - the actual value.default AbstractShortAssert<?> assertThat(short actual)
ShortAssertactual - the actual value.default AbstractLongAssert<?> assertThat(long actual)
LongAssertactual - the actual value.default AbstractLongAssert<?> assertThat(Long actual)
LongAssertactual - the actual value.default AbstractLongArrayAssert<?> assertThat(long[] actual)
LongArrayAssertactual - the actual value.default <T> ObjectAssert<T> assertThat(T actual)
ObjectAssertT - the type of the actual value.actual - the actual value.default AbstractStringAssert<?> assertThat(String actual)
CharSequenceAssertfrom a Stringactual - the actual value.default AbstractDateAssert<?> assertThat(Date actual)
DateAssertactual - the actual value.default AbstractThrowableAssert<?,? extends Throwable> assertThat(Throwable actual)
ThrowableAssertactual - the actual value.ThrowableAssert.default AbstractBigDecimalAssert<?> assertThat(BigDecimal actual)
BigDecimalAssertactual - the actual value.default AbstractBigIntegerAssert<?> assertThat(BigInteger actual)
BigIntegerAssertactual - the actual value.default AtomicBooleanAssert assertThat(AtomicBoolean actual)
AtomicBoolean.actual - the actual value.default AtomicIntegerAssert assertThat(AtomicInteger actual)
AtomicInteger.actual - the actual value.default AtomicIntegerArrayAssert assertThat(AtomicIntegerArray actual)
AtomicIntegerArray.actual - the actual value.default <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT> assertThat(AtomicIntegerFieldUpdater<OBJECT> actual)
AtomicIntegerFieldUpdater.OBJECT - the type of the object holding the updatable field.actual - the actual value.default AtomicLongAssert assertThat(AtomicLong actual)
AtomicLong.actual - the actual value.default AtomicLongArrayAssert assertThat(AtomicLongArray actual)
AtomicLongArray.actual - the actual value.default <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT> assertThat(AtomicLongFieldUpdater<OBJECT> actual)
AtomicLongFieldUpdater.OBJECT - the type of the object holding the updatable field.actual - the actual value.default <VALUE> AtomicReferenceAssert<VALUE> assertThat(AtomicReference<VALUE> actual)
AtomicReference.VALUE - the type of the value contained in the AtomicReference.actual - the actual value.default <ELEMENT> AtomicReferenceArrayAssert<ELEMENT> assertThat(AtomicReferenceArray<ELEMENT> actual)
AtomicReferenceArray.ELEMENT - the type of the value contained in the AtomicReferenceArray.actual - the actual value.default <FIELD,OBJECT> AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT> assertThat(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)
AtomicReferenceFieldUpdater.FIELD - the type of the field which gets updated by the AtomicReferenceFieldUpdater.OBJECT - the type of the object holding the updatable field.actual - the actual value.default <VALUE> AtomicMarkableReferenceAssert<VALUE> assertThat(AtomicMarkableReference<VALUE> actual)
AtomicMarkableReference.VALUE - the type of the value contained in the AtomicMarkableReference.actual - the actual value.default <VALUE> AtomicStampedReferenceAssert<VALUE> assertThat(AtomicStampedReference<VALUE> actual)
AtomicStampedReference.VALUE - the type of the value contained in the AtomicStampedReference.actual - the actual value.default AbstractCharSequenceAssert<?,? extends CharSequence> assertThat(CharSequence actual)
CharSequenceAssertactual - the actual value.default AbstractCharSequenceAssert<?,? extends CharSequence> assertThat(StringBuilder actual)
CharSequenceAssertStringBuilder.actual - the actual value.default AbstractCharSequenceAssert<?,? extends CharSequence> assertThat(StringBuffer actual)
CharSequenceAssertStringBuffer.actual - the actual value.default AbstractShortArrayAssert<?> assertThat(short[] actual)
ShortArrayAssertactual - the actual value.default AbstractShortAssert<?> assertThat(Short actual)
ShortAssertactual - the actual value.default ClassAssert assertThat(Class<?> actual)
ClassAssertactual - the actual value.default AbstractCharacterAssert<?> assertThat(Character actual)
CharacterAssertactual - the actual value.default AbstractCharArrayAssert<?> assertThat(char[] actual)
CharArrayAssertactual - the actual value.default AbstractCharacterAssert<?> assertThat(char actual)
CharacterAssertactual - the actual value.default <T extends Comparable<? super T>> AbstractComparableAssert<?,T> assertThat(T actual)
GenericComparableAssertT - the type of actual.actual - the actual value.default <T> IterableAssert<T> assertThat(Iterable<? extends T> actual)
IterableAssertT - the type of elements.actual - the actual value.default <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> FactoryBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(Iterable<? extends ELEMENT> actual, AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
FactoryBasedNavigableIterableAssertIterable element
in order to perform assertions on it.
Navigational methods provided:
The available assertions after navigating to an element depend on the ELEMENT_ASSERT parameter of the given
AssertFactory<ELEMENT, ELEMENT_ASSERT> (AssertJ can't figure it out because of Java type erasure).
Example with String element assertions:
Iterable<String> hobbits = newHashSet("frodo", "sam", "pippin");
// build an AssertFactory for StringAssert (much nicer with Java 8 lambdas)
AssertFactory<String, StringAssert> stringAssertFactory = new AssertFactory<String, StringAssert>() {
@Override
public StringAssert createAssert(String string) {
return new StringAssert(string);
}
};
// assertion succeeds with String assertions chained after first()
assertThat(hobbits, stringAssertFactory).first()
.startsWith("fro")
.endsWith("do");ACTUAL - The actual typeELEMENT - The actual elements typeELEMENT_ASSERT - The actual elements AbstractAssert typeactual - the actual value.assertFactory - the factory used to create the elements assert instance.default <T> IteratorAssert<T> assertThat(Iterator<? extends T> actual)
IteratorAssert
Breaking change in version 3.12.0: this method does not return anymore an IterableAssert but an IteratorAssert.
In order to access assertions from IterableAssert, use AbstractIteratorAssert.toIterable().
IteratorAssert instances have limited assertions because it does not consume iterator's elements.
Examples:
Iterator<String> bestBasketBallPlayers = getBestBasketBallPlayers();
assertThat(bestBasketBallPlayers).hasNext() // Iterator assertion
.toIterable() // switch to Iterable assertions
.contains("Jordan", "Magic", "Lebron"); // Iterable assertion T - the type of elements.actual - the actual value.default <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> ClassBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(ACTUAL actual, Class<ELEMENT_ASSERT> assertClass)
ClassBasedNavigableIterableAssertIterable element
in order to perform assertions on it.
Navigational methods provided:
The available assertions after navigating to an element depend on the given assertClass
(AssertJ can't find the element assert type by itself because of Java type erasure).
Example with String element assertions:
Iterable<String> hobbits = newHashSet("frodo", "sam", "pippin");
// assertion succeeds with String assertions chained after first()
assertThat(hobbits, StringAssert.class).first()
.startsWith("fro")
.endsWith("do");ACTUAL - The actual typeELEMENT - The actual elements typeELEMENT_ASSERT - The actual elements AbstractAssert typeactual - the actual value.assertClass - the class used to create the elements assert instance.default AbstractBooleanAssert<?> assertThat(Boolean actual)
BooleanAssertactual - the actual value.default AbstractBooleanArrayAssert<?> assertThat(boolean[] actual)
BooleanArrayAssertactual - the actual value.default AbstractByteAssert<?> assertThat(byte actual)
ByteAssertactual - the actual value.default AbstractByteAssert<?> assertThat(Byte actual)
ByteAssertactual - the actual value.default AbstractByteArrayAssert<?> assertThat(byte[] actual)
ByteArrayAssertactual - the actual value.default AbstractBooleanAssert<?> assertThat(boolean actual)
BooleanAssertactual - the actual value.default AbstractFloatAssert<?> assertThat(float actual)
FloatAssertactual - the actual value.default AbstractInputStreamAssert<?,? extends InputStream> assertThat(InputStream actual)
InputStreamAssertactual - the actual value.default AbstractFileAssert<?> assertThat(File actual)
FileAssertactual - the actual value.default <RESULT> FutureAssert<RESULT> assertThat(Future<RESULT> actual)
Future.RESULT - the type of the value contained in the Future.actual - the actual value.default AbstractPathAssert<?> assertThat(Path actual)
PathAssertactual - the path to testdefault AbstractIntArrayAssert<?> assertThat(int[] actual)
IntArrayAssertactual - the actual value.default AbstractFloatAssert<?> assertThat(Float actual)
FloatAssertactual - the actual value.default AbstractIntegerAssert<?> assertThat(int actual)
IntegerAssertactual - the actual value.default AbstractFloatArrayAssert<?> assertThat(float[] actual)
FloatArrayAssertactual - the actual value.default AbstractIntegerAssert<?> assertThat(Integer actual)
IntegerAssertactual - the actual value.default AbstractDoubleAssert<?> assertThat(double actual)
DoubleAssertactual - the actual value.default AbstractDoubleAssert<?> assertThat(Double actual)
DoubleAssertactual - the actual value.default <T> ListAssert<T> assertThat(List<? extends T> actual)
ListAssertT - the type of elements.actual - the actual value.default <ELEMENT,ACTUAL extends List<? extends ELEMENT>,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> ClassBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(List<? extends ELEMENT> actual, Class<ELEMENT_ASSERT> assertClass)
ClassBasedNavigableListAssertList element
in order to perform assertions on it.
Navigational methods provided:
The available assertions after navigating to an element depend on the given assertClass
(AssertJ can't find the element assert type by itself because of Java type erasure).
Example with String element assertions:
List<String> hobbits = newArrayList("frodo", "sam", "pippin");
// assertion succeeds with String assertions chained after first()
assertThat(hobbits, StringAssert.class).first()
.startsWith("fro")
.endsWith("do");ACTUAL - The actual typeELEMENT - The actual elements typeELEMENT_ASSERT - The actual elements AbstractAssert typeactual - the actual value.assertClass - the class used to create the elements assert instance.default <ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> FactoryBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(List<? extends ELEMENT> actual, AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
FactoryBasedNavigableListAssertList element
in order to perform assertions on it.
Navigational methods provided:
The available assertions after navigating to an element depend on the ELEMENT_ASSERT parameter of the given
AssertFactory<ELEMENT, ELEMENT_ASSERT> (AssertJ can't figure it out because of Java type erasure).
Example with String element assertions:
List<String> hobbits = newArrayList("frodo", "sam", "pippin");
// build an AssertFactory for StringAssert (much nicer with Java 8 lambdas)
AssertFactory<String, StringAssert> stringAssertFactory = new AssertFactory<String, StringAssert>() {
@Override
public StringAssert createAssert(String string) {
return new StringAssert(string);
}
};
// assertion succeeds with String assertions chained after first()
assertThat(hobbits, stringAssertFactory).first()
.startsWith("fro")
.endsWith("do");ACTUAL - The actual typeELEMENT - The actual elements typeELEMENT_ASSERT - The actual elements AbstractAssert typeactual - the actual value.assertFactory - the factory used to create the elements assert instance.default <ELEMENT> ListAssert<ELEMENT> assertThat(Stream<? extends ELEMENT> actual)
ListAssertStream.
Be aware that the Stream under test will be converted to a List when an assertions require to inspect its content.
Once this is done the Stream can't reused as it would have been consumed.
Calling multiple methods on the returned ListAssert is safe as it only interacts with the List built from the Stream.
Examples:
// you can chain multiple assertions on the Stream as it is converted to a List
assertThat(Stream.of(1, 2, 3)).contains(1)
.doesNotContain(42);The following assertion fails as the Stream under test is converted to a List before being compared to the expected Stream:
// FAIL: the Stream under test is converted to a List and compared to a Stream but a List is not a Stream.
assertThat(Stream.of(1, 2, 3)).isEqualTo(Stream.of(1, 2, 3));
These assertions succeed as isEqualTo and isSameAs checks references which does not require to convert the Stream to a List.
// The following assertions succeed as it only performs reference checking which does not require to convert the Stream to a List
Stream<Integer> stream = Stream.of(1, 2, 3);
assertThat(stream).isEqualTo(stream)
.isSameAs(stream);ELEMENT - the type of elements.actual - the actual Stream value.default ListAssert<Double> assertThat(DoubleStream actual)
ListAssertDoubleStream.
Be aware that the DoubleStream under test will be converted to a List when an assertions require to inspect its content.
Once this is done the DoubleStream can't reused as it would have been consumed.
Calling multiple methods on the returned ListAssert is safe as it only interacts with the List built from the DoubleStream.
Examples:
// you can chain multiple assertions on the DoubleStream as it is converted to a List
assertThat(DoubleStream.of(1.0, 2.0, 3.0)).contains(1.0)
.doesNotContain(42.0);The following assertion fails as the DoubleStream under test is converted to a List before being compared to the expected DoubleStream:
// FAIL: the DoubleStream under test is converted to a List and compared to a DoubleStream but a List is not a DoubleStream.
assertThat(DoubleStream.of(1.0, 2.0, 3.0)).isEqualTo(DoubleStream.of(1.0, 2.0, 3.0));
These assertions succeed as isEqualTo and isSameAs checks references which does not require to convert the DoubleStream to a List.
// The following assertions succeed as it only performs reference checking which does not require to convert the DoubleStream to a List
DoubleStream stream = DoubleStream.of(1.0, 2.0, 3.0);
assertThat(stream).isEqualTo(stream)
.isSameAs(stream);actual - the actual DoubleStream value.default ListAssert<Long> assertThat(LongStream actual)
ListAssertLongStream.
Be aware that the LongStream under test will be converted to a List when an assertions require to inspect its content.
Once this is done the LongStream can't reused as it would have been consumed.
Calling multiple methods on the returned ListAssert is safe as it only interacts with the List built from the LongStream.
Examples:
// you can chain multiple assertions on the LongStream as it is converted to a List
assertThat(LongStream.of(1, 2, 3)).contains(1)
.doesNotContain(42);The following assertion fails as the LongStream under test is converted to a List before being compared to the expected LongStream:
// FAIL: the LongStream under test is converted to a List and compared to a LongStream but a List is not a LongStream.
assertThat(LongStream.of(1, 2, 3)).isEqualTo(LongStream.of(1, 2, 3));
These assertions succeed as isEqualTo and isSameAs checks references which does not require to convert the LongStream to a List.
// The following assertions succeed as it only performs reference checking which does not require to convert the LongStream to a List
LongStream stream = LongStream.of(1, 2, 3);
assertThat(stream).isEqualTo(stream)
.isSameAs(stream);actual - the actual LongStream value.default ListAssert<Integer> assertThat(IntStream actual)
ListAssertIntStream.
Be aware that the IntStream under test will be converted to a List when an assertions require to inspect its content.
Once this is done the IntStream can't reused as it would have been consumed.
Calling multiple methods on the returned ListAssert is safe as it only interacts with the List built from the IntStream.
Examples:
// you can chain multiple assertions on the IntStream as it is converted to a List
assertThat(IntStream.of(1, 2, 3)).contains(1)
.doesNotContain(42);The following assertion fails as the IntStream under test is converted to a List before being compared to the expected IntStream:
// FAIL: the IntStream under test is converted to a List and compared to a IntStream but a List is not a IntStream.
assertThat(IntStream.of(1, 2, 3)).isEqualTo(IntStream.of(1, 2, 3));
These assertions succeed as isEqualTo and isSameAs checks references which does not require to convert the IntStream to a List.
// The following assertions succeed as it only performs reference checking which does not require to convert the IntStream to a List
IntStream stream = IntStream.of(1, 2, 3);
assertThat(stream).isEqualTo(stream)
.isSameAs(stream);actual - the actual IntStream value.default AbstractDoubleArrayAssert<?> assertThat(double[] actual)
DoubleArrayAssertactual - the actual value.default Properties<Object> extractProperty(String propertyName)
Properties.extractProperty(String) so that Assertions offers a full feature entry point
to
all AssertJ features (but you can use Properties if you prefer).
Typical usage is to chain extractProperty with from method, see examples below :
// extract simple property values, as no type has been defined the extracted property will be considered as Object
// to define the real property type (here String) use extractProperty("name", String.class) instead.
assertThat(extractProperty("name").from(fellowshipOfTheRing))
.contains("Boromir", "Gandalf", "Frodo", "Legolas")
.doesNotContain("Sauron", "Elrond");
// extracting property works also with user's types (here Race), even though it will be considered as Object
// to define the real property type (here String) use extractProperty("name", Race.class) instead.
assertThat(extractProperty("race").from(fellowshipOfTheRing)).contains(HOBBIT, ELF).doesNotContain(ORC);
// extract nested property on Race
assertThat(extractProperty("race.name").from(fellowshipOfTheRing)).contains("Hobbit", "Elf").doesNotContain("Orc"); propertyName - the name of the property to be read from the elements of a Iterable. It may be a nested
property (e.g. "address.street.number").Properties.NullPointerException - if the given property name is null.IllegalArgumentException - if the given property name is empty.default <T> Properties<T> extractProperty(String propertyName, Class<T> propertyType)
Properties.extractProperty(String) so that Assertions offers a full feature entry point
to
all AssertJ features (but you can use Properties if you prefer).
Typical usage is to chain extractProperty with from method, see examples below :
// extract simple property values having a java standard type (here String)
assertThat(extractProperty("name", String.class).from(fellowshipOfTheRing))
.contains("Boromir", "Gandalf", "Frodo", "Legolas")
.doesNotContain("Sauron", "Elrond");
// extracting property works also with user's types (here Race)
assertThat(extractProperty("race", String.class).from(fellowshipOfTheRing))
.contains(HOBBIT, ELF).doesNotContain(ORC);
// extract nested property on Race
assertThat(extractProperty("race.name", String.class).from(fellowshipOfTheRing))
.contains("Hobbit", "Elf")
.doesNotContain("Orc");T - the type of value to extract.propertyName - the name of the property to be read from the elements of a Iterable. It may be a nested
property (e.g. "address.street.number").propertyType - the type of property to extractProperties.NullPointerException - if the given property name is null.IllegalArgumentException - if the given property name is empty.default Tuple tuple(Object... values)
Tuple when working with AbstractIterableAssert.extracting(String...) or
AbstractObjectArrayAssert.extracting(String...)default Index atIndex(int index)
Index.atIndex(int) so that Assertions offers a full feature entry point to all AssertJ
features (but you can use Index if you prefer).
Typical usage :
List<Ring> elvesRings = newArrayList(vilya, nenya, narya);
assertThat(elvesRings).contains(vilya, atIndex(0)).contains(nenya, atIndex(1)).contains(narya, atIndex(2));index - the value of the index.Index.IllegalArgumentException - if the given value is negative.default Offset<Double> within(Double value)
offset(Double) to use with isCloseTo assertions.
Typical usage :
assertThat(8.1).isCloseTo(8.0, within(0.1));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<BigDecimal> within(BigDecimal value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(BigDecimal.TEN).isCloseTo(new BigDecimal("10.5"), within(BigDecimal.ONE));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Float> within(Float value)
offset(Float) to use with isCloseTo assertions.
Typical usage :
assertThat(8.2f).isCloseTo(8.0f, within(0.2f));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Double> withPrecision(Double value)
Offset.
Typical usage :
assertThat(8.1).isEqualTo(8.0, offset(0.1));value - the allowed offsetOffset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Float> withPrecision(Float value)
Offset.
Typical usage :
assertThat(8.2f).isCloseTo(8.0f, offset(0.2f));value - the allowed offsetOffset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<BigInteger> within(BigInteger value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(BigInteger.TEN).isCloseTo(new BigInteger("11"), within(new BigInteger("2")));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Byte> within(Byte value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat((byte) 10).isCloseTo((byte) 11, within((byte) 1));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Integer> within(Integer value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(10).isCloseTo(11, within(1));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Short> within(Short value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(10).isCloseTo(11, within(1));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Long> within(Long value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(5l).isCloseTo(7l, within(2l));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default TemporalUnitOffset within(long value, TemporalUnit unit)
TemporalUnitOffset with with less than or equal condition
to use with isCloseTo temporal assertions.
Typical usage :
LocalTime _07_10 = LocalTime.of(7, 10);
LocalTime _07_12 = LocalTime.of(7, 12);
assertThat(_07_10).isCloseTo(_07_12, within(5, ChronoUnit.MINUTES));value - the allowed offsetunit - the TemporalUnit of the offsetOffset.default Percentage withinPercentage(Double value)
Percentage to use with isCloseTo assertions for
percentages.
Typical usage :
assertThat(11.0).isCloseTo(10.0, withinPercentage(10.0));value - the required precision percentagePercentage.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Percentage withinPercentage(Integer value)
Percentage to use with isCloseTo assertions for
percentages.
Typical usage :
assertThat(11).isCloseTo(10, withinPercentage(10));value - the required precision percentagePercentage.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Percentage withinPercentage(Long value)
Percentage to use with isCloseTo assertions for
percentages.
Typical usage :
assertThat(11L).isCloseTo(10L, withinPercentage(10L));value - the required precision percentagePercentage.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Double> byLessThan(Double value)
offset(Double) to use with isCloseTo assertions.
Typical usage :
assertThat(8.1).isCloseTo(8.0, byLessThan(0.1));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Float> byLessThan(Float value)
offset(Float) to use with isCloseTo assertions.
Typical usage :
assertThat(8.2f).isCloseTo(8.0f, byLessThan(0.2f));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<BigDecimal> byLessThan(BigDecimal value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(BigDecimal.TEN).isCloseTo(new BigDecimal("10.5"), byLessThan(BigDecimal.ONE));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<BigInteger> byLessThan(BigInteger value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(BigInteger.TEN).isCloseTo(new BigInteger("11"), byLessThan(new BigInteger("2")));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Byte> byLessThan(Byte value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat((byte) 10).isCloseTo((byte) 11, byLessThan((byte) 1));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Integer> byLessThan(Integer value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(10).isCloseTo(11, byLessThan(1));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Short> byLessThan(Short value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(10).isCloseTo(11, byLessThan(1));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Long> byLessThan(Long value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(5l).isCloseTo(7l, byLessThan(2l));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default TemporalUnitOffset byLessThan(long value, TemporalUnit unit)
TemporalUnitOffset with strict less than condition
to use with isCloseTo temporal assertions.
Typical usage :
LocalTime _07_10 = LocalTime.of(7, 10);
LocalTime _07_12 = LocalTime.of(7, 12);
assertThat(_07_10).isCloseTo(_07_12, byLessThan(5, ChronoUnit.MINUTES));value - the value of the offset.unit - the TemporalUnit of the offset.Offset.default <F,T> Function<F,T> from(Function<F,T> extractor)
AbstractObjectAssert.returns(Object, Function).
Example:
Jedi yoda = new Jedi("Yoda", "Green");
assertThat(yoda).returns("Yoda", from(Jedi::getName))
.returns(2.4, from(Jedi::getHeight))
.returns(150, from(Jedi::getWeight)); F - Type of test subjectT - Type of the property under the assertionextractor - A function to extract test subject's propertyextractordefault <T> Condition<T> anyOf(Iterable<? extends Condition<? super T>> conditions)
AnyOfT - the type of object the given condition accept.conditions - the conditions to evaluate.AnyOf.NullPointerException - if the given iterable is null.NullPointerException - if any of the elements in the given iterable is null.default <T> Condition<T> anyOf(Condition<? super T>... conditions)
AnyOf.anyOf(Condition...) so that Assertions offers a full feature entry point to all
AssertJ features (but you can use AnyOf if you prefer).
Typical usage (jedi and sith are Condition) :
assertThat("Vader").is(anyOf(jedi, sith));T - the type of object the given condition accept.conditions - the conditions to evaluate.AnyOf.default <T> DoesNotHave<T> doesNotHave(Condition<? super T> condition)
DoesNotHaveT - the type of object the given condition accept.condition - the condition to inverse.default String contentOf(File file, String charsetName)
assertThat(String).
Note that this will load the entire file in memory; for larger files, there might be a more efficient alternative
with assertThat(File).
file - the file.charsetName - the name of the character set to use.IllegalArgumentException - if the given character set is not supported on this platform.UncheckedIOException - if an I/O exception occurs.default String contentOf(File file)
assertThat(String).
Note that this will load the entire file in memory; for larger files, there might be a more efficient alternative
with assertThat(File).
file - the file.UncheckedIOException - if an I/O exception occurs.default String contentOf(File file, Charset charset)
assertThat(String).
Note that this will load the entire file in memory; for larger files, there might be a more efficient alternative
with assertThat(File).
file - the file.charset - the character set to use.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default List<String> linesOf(File file)
file - the file.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default List<String> linesOf(File file, String charsetName)
file - the file.charsetName - the name of the character set to use.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default List<String> linesOf(File file, Charset charset)
file - the file.charset - the character set to use.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default void setRemoveAssertJRelatedElementsFromStackTrace(boolean removeAssertJRelatedElementsFromStackTrace)
removeAssertJRelatedElementsFromStackTrace - flag.default <T> T failBecauseExceptionWasNotThrown(Class<? extends Throwable> throwableClass)
AssertionError with a message explaining that a Throwable of given class was expected to be thrown
but had not been.
Assertions.shouldHaveThrown(Class) can be used as a replacement.
T - dummy return value typethrowableClass - the Throwable class that was expected to be thrown.AssertionError - with a message explaining that a Throwable of given class was expected to be thrown but had
not been.default <T> T shouldHaveThrown(Class<? extends Throwable> throwableClass)
AssertionError with a message explaining that a Throwable of given class was expected to be thrown
but had not been.T - dummy return value typethrowableClass - the Throwable class that was expected to be thrown.AssertionError - with a message explaining that a Throwable of given class was expected to be thrown but had
not been.default void setMaxLengthForSingleLineDescription(int maxLengthForSingleLineDescription)
The following array will be formatted on one line as its length < 80:
String[] greatBooks = array("A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice");
// formatted as:
["A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice"] String[] greatBooks = array("A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice", "Guards! Guards! (Discworld)");
// formatted as:
["A Game of Thrones",
"The Lord of the Rings",
"Assassin's Apprentice",
"Guards! Guards! (Discworld)"]maxLengthForSingleLineDescription - the maximum length for an iterable/array to be displayed on one linedefault void setMaxElementsForPrinting(int maxElementsForPrinting)
3.
The following array will be formatted entirely as it's length is <= 3:
String[] greatBooks = array("A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice");
// formatted as:
["A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice"]...:
String[] greatBooks = array("A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice", "Guards! Guards!");
// formatted as:
["A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice", ...]maxElementsForPrinting - the maximum elements that would be printed from one iterable/array/mapdefault void setAllowExtractingPrivateFields(boolean allowExtractingPrivateFields)
IterableAssert#extracting(String)ObjectArrayAssert#extracting(String)allowExtractingPrivateFields - allow private fields extraction. Default true.default void setAllowComparingPrivateFields(boolean allowComparingPrivateFields)
AbstractIterableAssert.usingElementComparatorOnFields(java.lang.String...)AbstractObjectAssert.isEqualToComparingFieldByField(Object)false and these methods try to compare private fields, it will fail with an exception.allowComparingPrivateFields - allow private fields comparison. Default true.default void setExtractBareNamePropertyMethods(boolean barenamePropertyMethods)
String name().
Defaults to enabled.barenamePropertyMethods - whether bare-named property methods are founddefault void setLenientDateParsing(boolean value)
With strict parsing, inputs must match exactly date/time format.
Example:
final Date date = Dates.parse("2001-02-03");
final Date dateTime = parseDatetime("2001-02-03T04:05:06");
final Date dateTimeWithMs = parseDatetimeWithMs("2001-02-03T04:05:06.700");
Assertions.setLenientDateParsing(true);
// assertions will pass
assertThat(date).isEqualTo("2001-01-34");
assertThat(date).isEqualTo("2001-02-02T24:00:00");
assertThat(date).isEqualTo("2001-02-04T-24:00:00.000");
assertThat(dateTime).isEqualTo("2001-02-03T04:05:05.1000");
assertThat(dateTime).isEqualTo("2001-02-03T04:04:66");
assertThat(dateTimeWithMs).isEqualTo("2001-02-03T04:05:07.-300");
// assertions will fail
assertThat(date).hasSameTimeAs("2001-02-04"); // different date
assertThat(dateTime).hasSameTimeAs("2001-02-03 04:05:06"); // leniency does not help heresetLenientDateParsing(false).value - whether lenient parsing mode should be enabled or notdefault void registerCustomDateFormat(DateFormat userCustomDateFormat)
AbstractDateAssert.isEqualTo(String).
User date formats are used before default ones in the order they have been registered (first registered, first used).
AssertJ is gonna use any date formats registered with one of these methods :
AbstractDateAssert.withDateFormat(String)AbstractDateAssert.withDateFormat(java.text.DateFormat)registerCustomDateFormat(java.text.DateFormat)registerCustomDateFormat(String)Beware that AssertJ will use the newly registered format for all remaining Date assertions in the test suite
To revert to default formats only, call useDefaultDateFormatsOnly() or
AbstractDateAssert.withDefaultDateFormatsOnly().
Code examples:
Date date = ... // set to 2003 April the 26th
assertThat(date).isEqualTo("2003-04-26");
try {
// date with a custom format : failure since the default formats don't match.
assertThat(date).isEqualTo("2003/04/26");
} catch (AssertionError e) {
assertThat(e).hasMessage("Failed to parse 2003/04/26 with any of these date formats: " +
"[yyyy-MM-dd'T'HH:mm:ss.SSS, yyyy-MM-dd'T'HH:mm:ss, yyyy-MM-dd]");
}
// registering a custom date format to make the assertion pass
registerCustomDateFormat(new SimpleDateFormat("yyyy/MM/dd")); // registerCustomDateFormat("yyyy/MM/dd") would work to.
assertThat(date).isEqualTo("2003/04/26");
// the default formats are still available and should work
assertThat(date).isEqualTo("2003-04-26");userCustomDateFormat - the new Date format used for String based Date assertions.default void registerCustomDateFormat(String userCustomDateFormatPattern)
AbstractDateAssert.isEqualTo(String).
User date formats are used before default ones in the order they have been registered (first registered, first used).
AssertJ is gonna use any date formats registered with one of these methods :
AbstractDateAssert.withDateFormat(String)AbstractDateAssert.withDateFormat(java.text.DateFormat)registerCustomDateFormat(java.text.DateFormat)registerCustomDateFormat(String)Beware that AssertJ will use the newly registered format for all remaining Date assertions in the test suite.
To revert to default formats only, call useDefaultDateFormatsOnly() or
AbstractDateAssert.withDefaultDateFormatsOnly().
Code examples:
Date date = ... // set to 2003 April the 26th
assertThat(date).isEqualTo("2003-04-26");
try {
// date with a custom format : failure since the default formats don't match.
assertThat(date).isEqualTo("2003/04/26");
} catch (AssertionError e) {
assertThat(e).hasMessage("Failed to parse 2003/04/26 with any of these date formats: " +
"[yyyy-MM-dd'T'HH:mm:ss.SSS, yyyy-MM-dd'T'HH:mm:ss, yyyy-MM-dd]");
}
// registering a custom date format to make the assertion pass
registerCustomDateFormat("yyyy/MM/dd");
assertThat(date).isEqualTo("2003/04/26");
// the default formats are still available and should work
assertThat(date).isEqualTo("2003-04-26");userCustomDateFormatPattern - the new Date format pattern used for String based Date assertions.default void useDefaultDateFormatsOnly()
Beware that the default formats are expressed in the current local timezone.
Defaults date format are:
yyyy-MM-dd'T'HH:mm:ss.SSSyyyy-MM-dd HH:mm:ss.SSS (for Timestamp String representation support)yyyy-MM-dd'T'HH:mm:ssyyyy-MM-ddExample of valid string date representations:
2003-04-26T03:01:02.9992003-04-26 03:01:02.9992003-04-26T13:01:022003-04-26default AbstractZonedDateTimeAssert<?> assertThat(ZonedDateTime actual)
ZonedDateTimeAssertactual - the actual value.default <RESULT> CompletableFutureAssert<RESULT> assertThat(CompletableFuture<RESULT> future)
CompletableFuture.RESULT - the type of the value contained in the CompletableFuture.future - the actual value.default <RESULT> CompletableFutureAssert<RESULT> assertThat(CompletionStage<RESULT> completionStage)
CompletionStage by converting it to a CompletableFuture and returning a CompletableFutureAssert.
If the given CompletionStage is null, the CompletableFuture in the returned CompletableFutureAssert will also be null.
RESULT - the type of the value contained in the CompletionStage.completionStage - the actual CompletionStage.default <VALUE> OptionalAssert<VALUE> assertThat(Optional<VALUE> optional)
Optional.VALUE - the type of the value contained in the Optional.optional - the actual value.default OptionalDoubleAssert assertThat(OptionalDouble optional)
OptionalDouble.optional - the actual value.default OptionalIntAssert assertThat(OptionalInt optional)
OptionalInt.optional - the actual value.default OptionalLongAssert assertThat(OptionalLong optional)
OptionalLong.optional - the actual value.default AbstractLocalDateTimeAssert<?> assertThat(LocalDateTime localDateTime)
LocalDateTimeAssertlocalDateTime - the actual value.default AbstractLocalDateAssert<?> assertThat(LocalDate localDate)
LocalDateAssertlocalDate - the actual value.default AbstractLocalTimeAssert<?> assertThat(LocalTime localTime)
LocalTimeAssertlocalTime - the actual value.default AbstractInstantAssert<?> assertThat(Instant actual)
InstantAssertactual - the actual value.default AbstractOffsetTimeAssert<?> assertThat(OffsetTime offsetTime)
OffsetTimeAssertoffsetTime - the actual value.default AbstractOffsetDateTimeAssert<?> assertThat(OffsetDateTime offsetDateTime)
OffsetTimeAssertoffsetDateTime - the actual value.default AbstractThrowableAssert<?,? extends Throwable> assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Throwable (easier done with lambdas).
Example :
@Test
public void testException() {
assertThatThrownBy(() -> { throw new Exception("boom!") }).isInstanceOf(Exception.class)
.hasMessageContaining("boom");
}ThrowableAssert.ThrowingCallable does not raise an exception, an error is immediately thrown,
in that case the test description provided with as(String, Object...) is not honored.catchThrowable(ThrowableAssert.ThrowingCallable) as shown below:
// assertion will fail but "display me" won't appear in the error
assertThatThrownBy(() -> {}).as("display me")
.isInstanceOf(Exception.class);
// assertion will fail AND "display me" will appear in the error
Throwable thrown = catchThrowable(() -> {});
assertThat(thrown).as("display me")
.isInstanceOf(Exception.class);assertThatCode(ThrowingCallable) for the test description provided
with as(String, Object...) to always be honored.shouldRaiseThrowable - The ThrowableAssert.ThrowingCallable or lambda with the code that should raise the throwable.ThrowableAssert.default AbstractThrowableAssert<?,? extends Throwable> assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable, String description, Object... args)
Throwable like assertThatThrownBy(ThrowingCallable) but this method
let you set the assertion description the same way you do with as(String, Object...).
Example:
@Test
public void testException() {
// if this assertion failed (but it doesn't), the error message would start with [Test explosive code]
assertThatThrownBy(() -> { throw new IOException("boom!") }, "Test explosive code")
.isInstanceOf(IOException.class)
.hasMessageContaining("boom");
}ThrowingCallable does not raise an exception, an error is immediately thrown.
The test description provided is honored but not the one with as(String, Object...), example:
// assertion will fail but "display me" won't appear in the error message
assertThatThrownBy(() -> {}).as("display me")
.isInstanceOf(Exception.class);
// assertion will fail AND "display me" will appear in the error message
assertThatThrownBy(() -> {}, "display me")
.isInstanceOf(Exception.class);shouldRaiseThrowable - The ThrowableAssert.ThrowingCallable or lambda with the code that should raise the throwable.description - the new description to set.args - optional parameter if description is a format String.ThrowableAssert.default AbstractThrowableAssert<?,? extends Throwable> assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)
Throwable more easily when used with Java 8 lambdas.
Example :
ThrowingCallable callable = () -> {
throw new Exception("boom!");
};
// assertion succeeds
assertThatCode(callable).isInstanceOf(Exception.class)
.hasMessageContaining("boom");
// assertion fails
assertThatCode(callable).doesNotThrowAnyException();ThrowableAssert.ThrowingCallable does not validate against next assertions, an error is immediately raised,
in that case the test description provided with as(String, Object...) is not honored.catchThrowable(ThrowableAssert.ThrowingCallable) as shown below.
ThrowingCallable doNothing = () -> {
// do nothing
};
// assertion fails and "display me" appears in the assertion error
assertThatCode(doNothing).as("display me")
.isInstanceOf(Exception.class);
// assertion will fail AND "display me" will appear in the error
Throwable thrown = catchThrowable(doNothing);
assertThatCode(thrown).as("display me")
.isInstanceOf(Exception.class);
This method was not named assertThat because the java compiler reported it ambiguous when used directly with a lambda :(
shouldRaiseOrNotThrowable - The ThrowableAssert.ThrowingCallable or lambda with the code that should raise the throwable.null if none was raised by the callable.default <T> ObjectAssert<T> assertThatObject(T actual)
ObjectAssert
This overload is useful, when an overloaded method of assertThat(...) takes precedence over the generic assertThat(Object).
Example:
Cast necessary becauseassertThat(List) "forgets" actual type:
assertThat(new LinkedList<>(asList("abc"))).matches(list -> ((Deque<String>) list).getFirst().equals("abc")); assertThatObject(new LinkedList<>(asList("abc"))).matches(list -> list.getFirst().equals("abc")); T - the type of the actual value.actual - the actual value.default Throwable catchThrowable(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Throwable more easily when used with Java 8 lambdas.
This caught Throwable can then be asserted.
Example:
@Test
public void testException() {
// when
Throwable thrown = catchThrowable(() -> { throw new Exception("boom!"); });
// then
assertThat(thrown).isInstanceOf(Exception.class)
.hasMessageContaining("boom");
} shouldRaiseThrowable - The lambda with the code that should raise the exception.null if none was raised by the callable.catchThrowableOfType(ThrowableAssert.ThrowingCallable, Class)default <THROWABLE extends Throwable> THROWABLE catchThrowableOfType(ThrowableAssert.ThrowingCallable shouldRaiseThrowable, Class<THROWABLE> type)
Throwable of a specific type.
A call is made to catchThrowable(ThrowingCallable), if no exception is thrown catchThrowableOfType returns null,
otherwise it checks that the caught Throwable has the specified type then casts it to it before returning it,
making it convenient to perform subtype-specific assertions on the result.
Example:
class CustomParseException extends Exception {
int line;
int column;
public CustomParseException(String msg, int l, int c) {
super(msg);
line = l;
column = c;
}
}
CustomParseException e = catchThrowableOfType(() -> { throw new CustomParseException("boom!", 1, 5); },
CustomParseException.class);
// assertions pass
assertThat(e).hasMessageContaining("boom");
assertThat(e.line).isEqualTo(1);
assertThat(e.column).isEqualTo(5);
// fails as CustomParseException is not a RuntimeException
catchThrowableOfType(() -> { throw new CustomParseException("boom!", 1, 5); },
RuntimeException.class);THROWABLE - the Throwable type.shouldRaiseThrowable - The lambda with the code that should raise the exception.type - The type of exception that the code is expected to raise.null if none was raised by the callable.catchThrowable(ThrowableAssert.ThrowingCallable)default <T extends Throwable> ThrowableTypeAssert<T> assertThatExceptionOfType(Class<? extends T> exceptionType)
throwingCallable
which allows to chain assertions on the thrown exception.
Example:
assertThatExceptionOfType(IOException.class)
.isThrownBy(() -> { throw new IOException("boom!"); })
.withMessage("boom!"); assertThatThrownBy(ThrowableAssert.ThrowingCallable) but in a more natural way.T - the exception type.exceptionType - the exception type class.ThrowableTypeAssert.default ThrowableTypeAssert<NullPointerException> assertThatNullPointerException()
assertThatExceptionOfType(Class) for NullPointerException.ThrowableTypeAssert.default ThrowableTypeAssert<IllegalArgumentException> assertThatIllegalArgumentException()
assertThatExceptionOfType(Class) for IllegalArgumentException.ThrowableTypeAssert.default ThrowableTypeAssert<IOException> assertThatIOException()
assertThatExceptionOfType(Class) for IOException.ThrowableTypeAssert.default ThrowableTypeAssert<IllegalStateException> assertThatIllegalStateException()
assertThatExceptionOfType(Class) for IllegalStateException.ThrowableTypeAssert.default <T> PredicateAssert<T> assertThat(Predicate<T> actual)
Predicate.T - the type of the value contained in the Predicate.actual - the actual value.default IntPredicateAssert assertThat(IntPredicate actual)
IntPredicate.actual - the actual value.default LongPredicateAssert assertThat(LongPredicate actual)
LongPredicate.actual - the actual value.default DoublePredicateAssert assertThat(DoublePredicate actual)
DoublePredicate.actual - the actual value.default AbstractUrlAssert<?> assertThat(URL actual)
UrlAssertactual - the actual value.default AbstractUriAssert<?> assertThat(URI actual)
UriAssertactual - the actual value.default <T> T assertThat(AssertProvider<T> component)
Assert to the AssertProvider.assertThat() of the given component.
Read the comments on AssertProvider for an example of its usage.
T - the AssertProvider wrapped type.component - the component that creates its own assertAssert of the given componentdefault <E> Filters<E> filter(E[] array)
Filters.filter(Object[]) so that Assertions offers a full feature entry point to all
AssertJ features (but you can use Filters if you prefer).
Note that the given array is not modified, the filters are performed on an Iterable copy of the array.
Typical usage with Condition :
assertThat(filter(players).being(potentialMVP).get()).containsOnly(james, rose);and with filter language based on java bean property :
assertThat(filter(players).with("pointsPerGame").greaterThan(20).and("assistsPerGame").greaterThan(7).get())
.containsOnly(james, rose);E - the array elements type.array - the array to filter.Filtersdefault <E> Filters<E> filter(Iterable<E> iterableToFilter)
Filters.filter(Object[]) so that Assertions offers a full feature entry point to all
AssertJ features (but you can use Filters if you prefer).
Note that the given Iterable is not modified, the filters are performed on a copy.
Typical usage with Condition :
assertThat(filter(players).being(potentialMVP).get()).containsOnly(james, rose);and with filter language based on java bean property :
assertThat(filter(players).with("pointsPerGame").greaterThan(20)
.and("assistsPerGame").greaterThan(7).get())
.containsOnly(james, rose);default InFilter in(Object... values)
FilterOperator to use in filteredOn(String, FilterOperation) to express a filter keeping all Iterable elements whose property/field
value matches one of the given values.
As often, an example helps:
Employee yoda = new Employee(1L, new Name("Yoda"), 800);
Employee obiwan = new Employee(2L, new Name("Obiwan"), 800);
Employee luke = new Employee(3L, new Name("Luke", "Skywalker"), 26);
Employee noname = new Employee(4L, null, 50);
List<Employee> employees = newArrayList(yoda, luke, obiwan, noname);
assertThat(employees).filteredOn("age", in(800, 26))
.containsOnly(yoda, obiwan, luke);values - values to match (one match is sufficient)default NotInFilter notIn(Object... valuesNotToMatch)
FilterOperator to use in filteredOn(String, FilterOperation) to express a filter keeping all Iterable elements whose property/field
value matches does not match any of the given values.
As often, an example helps:
Employee yoda = new Employee(1L, new Name("Yoda"), 800);
Employee obiwan = new Employee(2L, new Name("Obiwan"), 800);
Employee luke = new Employee(3L, new Name("Luke", "Skywalker"), 26);
Employee noname = new Employee(4L, null, 50);
List<Employee> employees = newArrayList(yoda, luke, obiwan, noname);
assertThat(employees).filteredOn("age", notIn(800, 50))
.containsOnly(luke);valuesNotToMatch - values not to match (none of the values must match)default NotFilter not(Object valueNotToMatch)
FilterOperator to use in filteredOn(String, FilterOperation) to express a filter keeping all Iterable elements whose property/field
value matches does not match the given value.
As often, an example helps:
Employee yoda = new Employee(1L, new Name("Yoda"), 800);
Employee obiwan = new Employee(2L, new Name("Obiwan"), 800);
Employee luke = new Employee(3L, new Name("Luke", "Skywalker"), 26);
Employee noname = new Employee(4L, null, 50);
List<Employee> employees = newArrayList(yoda, luke, obiwan, noname);
assertThat(employees).filteredOn("age", not(800))
.containsOnly(luke, noname);valueNotToMatch - the value not to matchdefault String contentOf(URL url, Charset charset)
assertThat(String).
Note that this will load the entire contents in memory.
url - the URL.charset - the character set to use.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default String contentOf(URL url, String charsetName)
assertThat(String).
Note that this will load the entire contents in memory.
url - the URL.charsetName - the name of the character set to use.IllegalArgumentException - if the given character set is not supported on this platform.UncheckedIOException - if an I/O exception occurs.default String contentOf(URL url)
assertThat(String).
Note that this will load the entire file in memory; for larger files.
url - the URL.UncheckedIOException - if an I/O exception occurs.default List<String> linesOf(URL url)
url - the URL.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default List<String> linesOf(URL url, Charset charset)
url - the URL.charset - the character set to use.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default List<String> linesOf(URL url, String charsetName)
url - the URL.charsetName - the name of the character set to use.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default void useRepresentation(Representation customRepresentation)
Representation that will be used in all following assertions.
Representation are used to format types in assertions error messages.
An alternative way of using a different representation is to register one as a service,
this approach is described in Representation, it requires more work than this method
but has the advantage of not having to do anything in your tests and it would be applied to all the tests globally
Example :
private class Example {}
private class CustomRepresentation extends StandardRepresentation {
// override needed to hook specific formatting
@Override
public String toStringOf(Object o) {
if (o instanceof Example) return "Example";
// fallback to default formatting.
return super.toStringOf(o);
}
// change String representation
@Override
protected String toStringOf(String s) {
return "$" + s + "$";
}
}
Assertions.useRepresentation(new CustomRepresentation());
// this assertion fails ...
assertThat(new Example()).isNull();
// ... with error :
// "expected:<[null]> but was:<[Example]>"
// this one fails ...
assertThat("foo").startsWith("bar");
// ... with error :
// Expecting:
// <$foo$>
// to start with:
// <$bar$>customRepresentation - the Representation to usedefault <T> void registerFormatterForType(Class<T> type, Function<T,String> formatter)
Representation to format the different types involved, using this method
you can control the formatting of a given type by providing a specific formatter.
Registering a formatter makes it available for all AssertJ Representation:
Example :
// without specific formatter
assertThat(STANDARD_REPRESENTATION.toStringOf(123L)).isEqualTo("123L");
// register a formatter for Long
Assertions.registerFormatterForType(Long.class, value -> "$" + value + "$");
// now Long will be formatted between in $$ in error message.
assertThat(STANDARD_REPRESENTATION.toStringOf(longNumber)).isEqualTo("$123$");
// fails with error : expected:<$456$> but was:<$123$>
assertThat(123L).isEqualTo(456L);T - the type of format.type - the class of the type to formatformatter - the formatter Functiondefault void useDefaultRepresentation()
StandardRepresentation to revert the effect of calling useRepresentation(Representation).Copyright © 2014–2019 AssertJ. All rights reserved.