public class Assertions extends Object
For example:
int removed = employees.removeFired();
assertThat(removed).isZero();
List<Employee> newEmployees = employees.hired(TODAY);
assertThat(newEmployees).hasSize(6);
This class only contains all assertThat methods, if you have ambiguous method compilation error, use either AssertionsForClassTypes or AssertionsForInterfaceTypes
and if you need both, fully qualify you assertThat method.
Java 8 is picky when choosing the right assertThat method if the object under test is generic and bounded,
for example if foo is instance of T that extends Exception, java 8 will complain that it can't resolve
the proper assertThat method (normally assertThat(Throwable) as foo might implement an interface like List,
if that occurred assertThat(List) would also be a possible choice - thus confusing java 8.
This why Assertions have been split in AssertionsForClassTypes and AssertionsForInterfaceTypes
(see http://stackoverflow.com/questions/29499847/ambiguous-method-in-java-8-why).
| Modifier | Constructor and Description |
|---|---|
protected |
Assertions()
Creates a new
|
| Modifier and Type | Method and Description |
|---|---|
static <T> Condition<T> |
allOf(Condition<? super T>... conditions)
Creates a new
|
static <T> Condition<T> |
allOf(Iterable<? extends Condition<? super T>> conditions)
Creates a new
|
static <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). |
static <T> Condition<T> |
anyOf(Iterable<? extends Condition<? super T>> conditions)
Creates a new
|
static <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. |
static <T> T |
assertThat(AssertProvider<T> component)
Delegates the creation of the
Assert to the AssertProvider.assertThat() of the given component. |
static AtomicBooleanAssert |
assertThat(AtomicBoolean actual)
Create assertion for
AtomicBoolean. |
static AtomicIntegerAssert |
assertThat(AtomicInteger actual)
Create assertion for
AtomicInteger. |
static AtomicIntegerArrayAssert |
assertThat(AtomicIntegerArray actual)
Create int[] assertion for
AtomicIntegerArray. |
static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT> |
assertThat(AtomicIntegerFieldUpdater<OBJECT> actual)
Create assertion for
AtomicIntegerFieldUpdater. |
static AtomicLongAssert |
assertThat(AtomicLong actual)
Create assertion for
AtomicLong. |
static AtomicLongArrayAssert |
assertThat(AtomicLongArray actual)
Create assertion for
AtomicLongArray. |
static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT> |
assertThat(AtomicLongFieldUpdater<OBJECT> actual)
Create assertion for
AtomicLongFieldUpdater. |
static <VALUE> AtomicMarkableReferenceAssert<VALUE> |
assertThat(AtomicMarkableReference<VALUE> actual)
Create assertion for
AtomicMarkableReference. |
static <VALUE> AtomicReferenceAssert<VALUE> |
assertThat(AtomicReference<VALUE> actual)
Create assertion for
AtomicReference. |
static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT> |
assertThat(AtomicReferenceArray<ELEMENT> actual)
Create assertion for
AtomicReferenceArray. |
static <FIELD,OBJECT> |
assertThat(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)
Create assertion for
AtomicReferenceFieldUpdater. |
static <VALUE> AtomicStampedReferenceAssert<VALUE> |
assertThat(AtomicStampedReference<VALUE> actual)
Create assertion for
AtomicStampedReference. |
static AbstractBigDecimalAssert<?> |
assertThat(BigDecimal actual)
Creates a new instance of
|
static AbstractBigIntegerAssert<?> |
assertThat(BigInteger actual)
Creates a new instance of
|
static AbstractBooleanAssert<?> |
assertThat(boolean actual)
Creates a new instance of
|
static AbstractBooleanAssert<?> |
assertThat(Boolean actual)
Creates a new instance of
|
static AbstractBooleanArrayAssert<?> |
assertThat(boolean[] actual)
Creates a new instance of
|
static AbstractByteAssert<?> |
assertThat(byte actual)
Creates a new instance of
|
static AbstractByteAssert<?> |
assertThat(Byte actual)
Creates a new instance of
|
static AbstractByteArrayAssert<?> |
assertThat(byte[] actual)
Creates a new instance of
|
static AbstractCharacterAssert<?> |
assertThat(char actual)
Creates a new instance of
|
static AbstractCharArrayAssert<?> |
assertThat(char[] actual)
Creates a new instance of
|
static AbstractCharacterAssert<?> |
assertThat(Character actual)
Creates a new instance of
|
static AbstractCharSequenceAssert<?,? extends CharSequence> |
assertThat(CharSequence actual)
Creates a new instance of
|
static ClassAssert |
assertThat(Class<?> actual)
Creates a new instance of
|
static <RESULT> CompletableFutureAssert<RESULT> |
assertThat(CompletableFuture<RESULT> actual)
Create assertion for
CompletableFuture. |
static <RESULT> CompletableFutureAssert<RESULT> |
assertThat(CompletionStage<RESULT> actual)
Create assertion for
CompletionStage by converting it to a CompletableFuture and returning a CompletableFutureAssert. |
static AbstractDateAssert<?> |
assertThat(Date actual)
Creates a new instance of
|
static AbstractDoubleAssert<?> |
assertThat(double actual)
Creates a new instance of
|
static AbstractDoubleAssert<?> |
assertThat(Double actual)
Creates a new instance of
|
static AbstractDoubleArrayAssert<?> |
assertThat(double[] actual)
Creates a new instance of
|
static DoublePredicateAssert |
assertThat(DoublePredicate actual)
Create assertion for
DoublePredicate. |
static ListAssert<Double> |
assertThat(DoubleStream actual)
Creates a new instance of
DoubleStream. |
static AbstractFileAssert<?> |
assertThat(File actual)
Creates a new instance of
|
static AbstractFloatAssert<?> |
assertThat(float actual)
Creates a new instance of
|
static AbstractFloatAssert<?> |
assertThat(Float actual)
Creates a new instance of
|
static AbstractFloatArrayAssert<?> |
assertThat(float[] actual)
Creates a new instance of
|
static <RESULT> FutureAssert<RESULT> |
assertThat(Future<RESULT> actual)
Create assertion for
Future. |
static AbstractInputStreamAssert<?,? extends InputStream> |
assertThat(InputStream actual)
Creates a new instance of
|
static AbstractInstantAssert<?> |
assertThat(Instant actual)
Creates a new instance of
|
static AbstractIntegerAssert<?> |
assertThat(int actual)
Creates a new instance of
|
static AbstractIntArrayAssert<?> |
assertThat(int[] actual)
Creates a new instance of
|
static AbstractIntegerAssert<?> |
assertThat(Integer actual)
Creates a new instance of
|
static IntPredicateAssert |
assertThat(IntPredicate actual)
Create assertion for
IntPredicate. |
static ListAssert<Integer> |
assertThat(IntStream actual)
Creates a new instance of
IntStream. |
static <ELEMENT> IterableAssert<ELEMENT> |
assertThat(Iterable<? extends ELEMENT> actual)
Creates a new instance of
|
static <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. |
static <ELEMENT> IterableAssert<ELEMENT> |
assertThat(Iterator<? extends ELEMENT> actual)
Creates a new instance of
|
static <ELEMENT> ListAssert<ELEMENT> |
assertThat(List<? extends ELEMENT> actual)
Creates a new instance of
|
static <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. |
static <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. |
static AbstractLocalDateAssert<?> |
assertThat(LocalDate actual)
Creates a new instance of
|
static AbstractLocalDateTimeAssert<?> |
assertThat(LocalDateTime actual)
Creates a new instance of
|
static AbstractLocalTimeAssert<?> |
assertThat(LocalTime actual)
Creates a new instance of
|
static AbstractLongAssert<?> |
assertThat(long actual)
Creates a new instance of
|
static AbstractLongAssert<?> |
assertThat(Long actual)
Creates a new instance of
|
static AbstractLongArrayAssert<?> |
assertThat(long[] actual)
Creates a new instance of
|
static LongPredicateAssert |
assertThat(LongPredicate actual)
Create assertion for
LongPredicate. |
static ListAssert<Long> |
assertThat(LongStream actual)
Creates a new instance of
LongStream. |
static <K,V> MapAssert<K,V> |
assertThat(Map<K,V> actual)
Creates a new instance of
|
static AbstractOffsetDateTimeAssert<?> |
assertThat(OffsetDateTime actual)
Creates a new instance of
|
static AbstractOffsetTimeAssert<?> |
assertThat(OffsetTime actual)
Create assertion for
OffsetTime. |
static <VALUE> OptionalAssert<VALUE> |
assertThat(Optional<VALUE> actual)
Create assertion for
Optional. |
static OptionalDoubleAssert |
assertThat(OptionalDouble actual)
Create assertion for
OptionalDouble. |
static OptionalIntAssert |
assertThat(OptionalInt actual)
Create assertion for
OptionalInt. |
static OptionalLongAssert |
assertThat(OptionalLong actual)
Create assertion for
OptionalInt. |
static AbstractPathAssert<?> |
assertThat(Path actual)
Creates a new instance of
PathAssert |
static <T> PredicateAssert<T> |
assertThat(Predicate<T> actual)
Create assertion for
Predicate. |
static AbstractShortAssert<?> |
assertThat(short actual)
Creates a new instance of
|
static AbstractShortAssert<?> |
assertThat(Short actual)
Creates a new instance of
|
static AbstractShortArrayAssert<?> |
assertThat(short[] actual)
Creates a new instance of
|
static <ELEMENT> ListAssert<ELEMENT> |
assertThat(Stream<? extends ELEMENT> actual)
Creates a new instance of
Stream. |
static AbstractCharSequenceAssert<?,String> |
assertThat(String actual)
Creates a new instance of
|
static <T> ObjectAssert<T> |
assertThat(T actual)
Creates a new instance of
|
static <T extends Comparable<? super T>> |
assertThat(T actual)
Creates a new instance of
|
static <T extends AssertDelegateTarget> |
assertThat(T assertion)
Returns the given assertion.
|
static <T> ObjectArrayAssert<T> |
assertThat(T[] actual)
Creates a new instance of
|
static AbstractThrowableAssert<?,? extends Throwable> |
assertThat(Throwable actual)
Creates a new instance of
|
static AbstractUriAssert<?> |
assertThat(URI actual)
Creates a new instance of
|
static AbstractUrlAssert<?> |
assertThat(URL actual)
Creates a new instance of
|
static AbstractZonedDateTimeAssert<?> |
assertThat(ZonedDateTime actual)
Creates a new instance of
|
static AbstractThrowableAssert<?,? extends Throwable> |
assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)
Allows to capture and then assert on a
Throwable (easier done with lambdas). |
static <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. |
static ThrowableTypeAssert<IllegalArgumentException> |
assertThatIllegalArgumentException()
Alias for
assertThatExceptionOfType(Class) for IllegalArgumentException. |
static ThrowableTypeAssert<IllegalStateException> |
assertThatIllegalStateException()
Alias for
assertThatExceptionOfType(Class) for IllegalStateException. |
static ThrowableTypeAssert<IOException> |
assertThatIOException()
Alias for
assertThatExceptionOfType(Class) for IOException. |
static ThrowableTypeAssert<NullPointerException> |
assertThatNullPointerException()
Alias for
assertThatExceptionOfType(Class) for NullPointerException. |
static AbstractThrowableAssert<?,? extends Throwable> |
assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Allows to capture and then assert on a
Throwable (easier done with lambdas). |
static 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...). |
static 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). |
static Offset<BigDecimal> |
byLessThan(BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
static Offset<BigInteger> |
byLessThan(BigInteger value)
Assertions entry point for BigInteger
Offset to use with isCloseTo assertions. |
static Offset<Byte> |
byLessThan(Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
static Offset<Double> |
byLessThan(Double value)
Build a
strict Offset to use with AbstractDoubleAssert.isCloseTo(double, Offset) and AbstractDoubleAssert.isNotCloseTo(double, Offset) assertions. |
static Offset<Float> |
byLessThan(Float value)
Alias for
offset(Float) to use with isCloseTo assertions. |
static Offset<Integer> |
byLessThan(Integer value)
|
static Offset<Long> |
byLessThan(Long value)
|
static TemporalUnitOffset |
byLessThan(long value,
TemporalUnit unit)
Assertions entry point for
TemporalUnitOffset with strict less than condition
to use with isCloseTo temporal assertions. |
static Offset<Short> |
byLessThan(Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
static Throwable |
catchThrowable(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Allows catching a
Throwable more easily when used with Java 8 lambdas. |
static <THROWABLE extends Throwable> |
catchThrowableOfType(ThrowableAssert.ThrowingCallable shouldRaiseThrowable,
Class<THROWABLE> type)
Allows catching a
Throwable of a specific type. |
static 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). |
static String |
contentOf(File file,
Charset charset)
Loads the text content of a file, so that it can be passed to
assertThat(String). |
static String |
contentOf(File file,
String charsetName)
Loads the text content of a file, so that it can be passed to
assertThat(String). |
static 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). |
static String |
contentOf(URL url,
Charset charset)
Loads the text content of a URL, so that it can be passed to
assertThat(String). |
static String |
contentOf(URL url,
String charsetName)
Loads the text content of a URL, so that it can be passed to
assertThat(String). |
static <T> DoesNotHave<T> |
doesNotHave(Condition<? super T> condition)
Creates a new
|
static <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). |
static 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). |
static <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). |
static void |
fail(String failureMessage)
Throws an
AssertionError with the given message. |
static void |
fail(String failureMessage,
Object... args)
Throws an
AssertionError with the given message built as String.format(String, Object...). |
static void |
fail(String failureMessage,
Throwable realCause)
Throws an
AssertionError with the given message and with the Throwable that caused the failure. |
static void |
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. |
static <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). |
static <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). |
static <F,T> Function<F,T> |
from(Function<F,T> extractor)
A syntax sugar to write fluent assertion using
AbstractObjectAssert.returns(Object, Function). |
static 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. |
static 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.
|
static 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.
|
static 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.
|
static 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.
|
static 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.
|
static 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.
|
static <T> Not<T> |
not(Condition<? super T> condition)
Creates a new
|
static 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. |
static 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. |
static Offset<Double> |
offset(Double value)
Assertions entry point for double
Offset. |
static Offset<Float> |
offset(Float value)
Assertions entry point for float
Offset. |
static 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). |
static 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). |
static <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. |
static void |
setAllowComparingPrivateFields(boolean allowComparingPrivateFields)
Globally sets whether the use of private fields is allowed for comparison.
|
static void |
setAllowExtractingPrivateFields(boolean allowExtractingPrivateFields)
Globally sets whether
|
static 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).
|
static 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.
|
static 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.
|
static void |
setRemoveAssertJRelatedElementsFromStackTrace(boolean removeAssertJRelatedElementsFromStackTrace)
Sets whether we remove elements related to AssertJ from assertion error stack trace.
|
static void |
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. |
static Tuple |
tuple(Object... values)
Utility method to build nicely a
Tuple when working with AbstractIterableAssert.extracting(String...) or
AbstractObjectArrayAssert.extracting(String...) |
static void |
useDefaultDateFormatsOnly()
Remove all registered custom date formats => use only the defaults date formats to parse string as date.
|
static void |
useDefaultRepresentation()
Fallback to use
StandardRepresentation to revert the effect of calling useRepresentation(Representation). |
static void |
useRepresentation(Representation customRepresentation)
Register a
Representation that will be used in all following assertions. |
static Offset<BigDecimal> |
within(BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
static Offset<BigInteger> |
within(BigInteger value)
Assertions entry point for BigInteger
Offset to use with isCloseTo assertions. |
static Offset<Byte> |
within(Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
static Offset<Double> |
within(Double value)
Alias for
offset(Double) to use with isCloseTo assertions. |
static Offset<Float> |
within(Float value)
Alias for
offset(Float) to use with isCloseTo assertions. |
static Offset<Integer> |
within(Integer value)
Assertions entry point for Integer
Offset to use with isCloseTo assertions. |
static Offset<Long> |
within(Long value)
|
static TemporalUnitOffset |
within(long value,
TemporalUnit unit)
Assertions entry point for
TemporalUnitOffset with with less than or equal condition
to use with isCloseTo temporal assertions. |
static Offset<Short> |
within(Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
static Percentage |
withinPercentage(Double value)
Assertions entry point for Double
Percentage to use with isCloseTo assertions for
percentages. |
static Percentage |
withinPercentage(Integer value)
Assertions entry point for Integer
Percentage to use with isCloseTo assertions for
percentages. |
static Percentage |
withinPercentage(Long value)
Assertions entry point for Long
Percentage to use with isCloseTo assertions for
percentages. |
static Offset<Double> |
withPrecision(Double value)
Alias for
offset(Double) to use with real number assertions. |
static Offset<Float> |
withPrecision(Float value)
Alias for
offset(Float) to use with real number assertions. |
protected Assertions()
Assertionspublic static <T> PredicateAssert<T> assertThat(Predicate<T> actual)
Predicate.T - the type of the value contained in the Predicate.actual - the actual value.public static IntPredicateAssert assertThat(IntPredicate actual)
IntPredicate.actual - the actual value.public static LongPredicateAssert assertThat(LongPredicate actual)
LongPredicate.actual - the actual value.public static DoublePredicateAssert assertThat(DoublePredicate actual)
DoublePredicate.actual - the actual value.public static <RESULT> CompletableFutureAssert<RESULT> assertThat(CompletableFuture<RESULT> actual)
CompletableFuture.RESULT - the type of the value contained in the CompletableFuture.actual - the actual value.public static <RESULT> CompletableFutureAssert<RESULT> assertThat(CompletionStage<RESULT> actual)
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.actual - the actual value.public static <VALUE> OptionalAssert<VALUE> assertThat(Optional<VALUE> actual)
Optional.VALUE - the type of the value contained in the Optional.actual - the actual value.public static OptionalDoubleAssert assertThat(OptionalDouble actual)
OptionalDouble.actual - the actual value.public static OptionalIntAssert assertThat(OptionalInt actual)
OptionalInt.actual - the actual value.public static OptionalLongAssert assertThat(OptionalLong actual)
OptionalInt.actual - the actual value.public static AbstractBigDecimalAssert<?> assertThat(BigDecimal actual)
BigDecimalAssertactual - the actual value.public static AbstractBigIntegerAssert<?> assertThat(BigInteger actual)
BigIntegerAssertactual - the actual value.public static AbstractUriAssert<?> assertThat(URI actual)
UriAssertactual - the actual value.public static AbstractUrlAssert<?> assertThat(URL actual)
UrlAssertactual - the actual value.public static AbstractBooleanAssert<?> assertThat(boolean actual)
BooleanAssertactual - the actual value.public static AbstractBooleanAssert<?> assertThat(Boolean actual)
BooleanAssertactual - the actual value.public static AbstractBooleanArrayAssert<?> assertThat(boolean[] actual)
BooleanArrayAssertactual - the actual value.public static AbstractByteAssert<?> assertThat(byte actual)
ByteAssertactual - the actual value.public static AbstractByteAssert<?> assertThat(Byte actual)
ByteAssertactual - the actual value.public static AbstractByteArrayAssert<?> assertThat(byte[] actual)
ByteArrayAssertactual - the actual value.public static AbstractCharacterAssert<?> assertThat(char actual)
CharacterAssertactual - the actual value.public static AbstractCharArrayAssert<?> assertThat(char[] actual)
CharArrayAssertactual - the actual value.public static AbstractCharacterAssert<?> assertThat(Character actual)
CharacterAssertactual - the actual value.public static ClassAssert assertThat(Class<?> actual)
ClassAssertactual - the actual value.public static AbstractDoubleAssert<?> assertThat(double actual)
DoubleAssertactual - the actual value.public static AbstractDoubleAssert<?> assertThat(Double actual)
DoubleAssertactual - the actual value.public static AbstractDoubleArrayAssert<?> assertThat(double[] actual)
DoubleArrayAssertactual - the actual value.public static AbstractFileAssert<?> assertThat(File actual)
FileAssertactual - the actual value.public static <RESULT> FutureAssert<RESULT> assertThat(Future<RESULT> actual)
Future.RESULT - the type of the value contained in the Future.actual - the actual value.public static AbstractInputStreamAssert<?,? extends InputStream> assertThat(InputStream actual)
InputStreamAssertactual - the actual value.public static AbstractFloatAssert<?> assertThat(float actual)
FloatAssertactual - the actual value.public static AbstractFloatAssert<?> assertThat(Float actual)
FloatAssertactual - the actual value.public static AbstractFloatArrayAssert<?> assertThat(float[] actual)
FloatArrayAssertactual - the actual value.public static AbstractIntegerAssert<?> assertThat(int actual)
IntegerAssertactual - the actual value.public static AbstractIntArrayAssert<?> assertThat(int[] actual)
IntArrayAssertactual - the actual value.public static AbstractIntegerAssert<?> assertThat(Integer actual)
IntegerAssertactual - the actual value.public static <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.public static <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.public static <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.public static <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.public static AbstractLongAssert<?> assertThat(long actual)
LongAssertactual - the actual value.public static AbstractLongAssert<?> assertThat(Long actual)
LongAssertactual - the actual value.public static AbstractLongArrayAssert<?> assertThat(long[] actual)
LongArrayAssertactual - the actual value.public static <T> ObjectAssert<T> assertThat(T actual)
ObjectAssertT - the type of the actual value.actual - the actual value.public static <T> ObjectArrayAssert<T> assertThat(T[] actual)
ObjectArrayAssertT - the actual's elements type.actual - the actual value.public static AbstractShortAssert<?> assertThat(short actual)
ShortAssertactual - the actual value.public static AbstractShortAssert<?> assertThat(Short actual)
ShortAssertactual - the actual value.public static AbstractShortArrayAssert<?> assertThat(short[] actual)
ShortArrayAssertactual - the actual value.public static AbstractDateAssert<?> assertThat(Date actual)
DateAssertactual - the actual value.public static AbstractZonedDateTimeAssert<?> assertThat(ZonedDateTime actual)
ZonedDateTimeAssertactual - the actual value.public static AbstractLocalDateTimeAssert<?> assertThat(LocalDateTime actual)
LocalDateTimeAssertactual - the actual value.public static AbstractOffsetDateTimeAssert<?> assertThat(OffsetDateTime actual)
OffsetDateTimeactual - the actual value.public static AbstractOffsetTimeAssert<?> assertThat(OffsetTime actual)
OffsetTime.actual - the actual value.public static AbstractLocalTimeAssert<?> assertThat(LocalTime actual)
LocalTimeAssertactual - the actual value.public static AbstractLocalDateAssert<?> assertThat(LocalDate actual)
LocalDateAssertactual - the actual value.public static AbstractInstantAssert<?> assertThat(Instant actual)
InstantAssertactual - the actual value.public static AtomicBooleanAssert assertThat(AtomicBoolean actual)
AtomicBoolean.actual - the actual value.public static AtomicIntegerAssert assertThat(AtomicInteger actual)
AtomicInteger.actual - the actual value.public static AtomicIntegerArrayAssert assertThat(AtomicIntegerArray actual)
AtomicIntegerArray.actual - the actual value.public static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT> assertThat(AtomicIntegerFieldUpdater<OBJECT> actual)
AtomicIntegerFieldUpdater.OBJECT - the type of the object holding the updatable field.actual - the actual value.public static AtomicLongAssert assertThat(AtomicLong actual)
AtomicLong.actual - the actual value.public static AtomicLongArrayAssert assertThat(AtomicLongArray actual)
AtomicLongArray.actual - the actual value.public static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT> assertThat(AtomicLongFieldUpdater<OBJECT> actual)
AtomicLongFieldUpdater.OBJECT - the type of the object holding the updatable field.actual - the actual value.public static <VALUE> AtomicReferenceAssert<VALUE> assertThat(AtomicReference<VALUE> actual)
AtomicReference.VALUE - the type of the value contained in the AtomicReference.actual - the actual value.public static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT> assertThat(AtomicReferenceArray<ELEMENT> actual)
AtomicReferenceArray.ELEMENT - the type of the value contained in the AtomicReferenceArray.actual - the actual value.public static <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.public static <VALUE> AtomicMarkableReferenceAssert<VALUE> assertThat(AtomicMarkableReference<VALUE> actual)
AtomicMarkableReference.VALUE - the type of the value contained in the AtomicMarkableReference.actual - the actual value.public static <VALUE> AtomicStampedReferenceAssert<VALUE> assertThat(AtomicStampedReference<VALUE> actual)
AtomicStampedReference.VALUE - the type of the value contained in the AtomicStampedReference.actual - the actual value.public static AbstractThrowableAssert<?,? extends Throwable> assertThat(Throwable actual)
ThrowableAssertactual - the actual value.ThrowableAssert.public static AbstractThrowableAssert<?,? extends Throwable> assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Throwable (easier done with lambdas).
Java 8 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.public static 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.public static AbstractThrowableAssert<?,? extends Throwable> assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)
Throwable (easier done with lambdas).
The main difference with assertThatThrownBy(ThrowingCallable) is that
this method does not fail if no exception was thrown.
Example :
ThrowingCallable boomCode = () -> {
throw new Exception("boom!");
};
ThrowingCallable doNothing = () -> {};
// assertions succeed
assertThatCode(doNothing).doesNotThrowAnyException();
assertThatCode(boomCode).isInstanceOf(Exception.class)
.hasMessageContaining("boom");
// assertion fails
assertThatCode(boomCode).doesNotThrowAnyException();assertThatThrownBy(ThrowingCallable) the test description provided with
as(String, Object...) is always honored as shown below.
ThrowingCallable doNothing = () -> {};
// assertion fails and "display me" appears in the assertion error
assertThatCode(doNothing).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.ThrowableAssert.public static 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(ThrowingCallable, Class)public static <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 it returns null
otherwise it checks that the caught Throwable has the specified type and casts it making it convenient to perform subtype-specific assertions on it.
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 succeed
assertThat(e).hasMessageContaining("boom");
assertThat(e.line).isEqualTo(1);
assertThat(e.column).isEqualTo(5);
// succeeds as catchThrowableOfType returns null when the code does not thrown any exceptions
assertThat(catchThrowableOfType(() -> {}, Exception.class)).isNull();
// 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(ThrowingCallable)public static <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 the exception type.exceptionType - the exception type class.ThrowableTypeAssert.public static ThrowableTypeAssert<NullPointerException> assertThatNullPointerException()
assertThatExceptionOfType(Class) for NullPointerException.ThrowableTypeAssert.public static ThrowableTypeAssert<IllegalArgumentException> assertThatIllegalArgumentException()
assertThatExceptionOfType(Class) for IllegalArgumentException.ThrowableTypeAssert.public static ThrowableTypeAssert<IOException> assertThatIOException()
assertThatExceptionOfType(Class) for IOException.ThrowableTypeAssert.public static ThrowableTypeAssert<IllegalStateException> assertThatIllegalStateException()
assertThatExceptionOfType(Class) for IllegalStateException.ThrowableTypeAssert.public static void setRemoveAssertJRelatedElementsFromStackTrace(boolean removeAssertJRelatedElementsFromStackTrace)
removeAssertJRelatedElementsFromStackTrace - flag.public static void fail(String failureMessage)
AssertionError with the given message.failureMessage - error message.AssertionError - with the given message.public static void fail(String failureMessage, Object... args)
AssertionError with the given message built as String.format(String, Object...).failureMessage - error message.args - Arguments referenced by the format specifiers in the format string.AssertionError - with the given built message.public static void fail(String failureMessage, Throwable realCause)
AssertionError with the given message and with the Throwable that caused the failure.failureMessage - 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.public static void 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.
shouldHaveThrown(Class) can be used as a replacement.
throwableClass - 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.public static void 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.throwableClass - 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.public static 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 linepublic static 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/mappublic static <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.public static 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.public static Tuple tuple(Object... values)
Tuple when working with AbstractIterableAssert.extracting(String...) or
AbstractObjectArrayAssert.extracting(String...)public static void setAllowExtractingPrivateFields(boolean allowExtractingPrivateFields)
IterableAssert#extracting(String)ObjectArrayAssert#extracting(String)allowExtractingPrivateFields - allow private fields extraction. Default true.public static 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.public static <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.public static 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.public static Offset<Double> offset(Double value)
Offset.
Typical usage :
assertThat(0.1).isEqualTo(0.0, offset(0.1));value - the allowed offsetOffset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.public static Offset<Float> offset(Float value)
Offset.
Typical usage :
assertThat(0.2f).isCloseTo(0.0f, offset(0.2f));value - the allowed offsetOffset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.public static Offset<Double> within(Double value)
offset(Double) to use with isCloseTo assertions.
Typical usage :
assertThat(0.1).isCloseTo(0.0, within(0.1));value - the allowed offsetOffset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.public static Offset<Double> withPrecision(Double value)
offset(Double) to use with real number assertions.
Typical usage :
assertThat(0.1).isEqualTo(0.0, withPrecision(0.1));value - the required precisionOffset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.public static 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 allowed offsetOffset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.public static Offset<Float> withPrecision(Float value)
offset(Float) to use with real number assertions.
Typical usage :
assertThat(0.2f).isEqualTo(0.0f, withPrecision(0.2f));value - the required precisionOffset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.public static 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 allowed offsetOffset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.public static 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 allowed offsetOffset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.public static 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.public static 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.public static Offset<Short> within(Short value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(10).isCloseTo(11, within(1));value - the allowed offsetOffset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.public static Offset<Long> within(Long value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(5l).isCloseTo(7l, within(2l));value - the allowed offsetOffset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.public static 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.public static 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.public static 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.public static 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.public static Offset<Double> byLessThan(Double value)
strict Offset to use with AbstractDoubleAssert.isCloseTo(double, Offset) and AbstractDoubleAssert.isNotCloseTo(double, Offset) assertions.
A strict offset implies a strict comparison which means that isCloseTo will fail when abs(actual - expected) == offset.
Examples:
// assertion succeeds
assertThat(8.1).isCloseTo(8.0, byLessThan(0.2));
// assertions fail
assertThat(8.1).isCloseTo(8.0, byLessThan(0.1)); // strict comparison!
assertThat(8.1).isCloseTo(8.0, byLessThan(0.01));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.public static Offset<Float> byLessThan(Float value)
offset(Float) to use with isCloseTo assertions.
Typical usage :
assertThat(8.2f).isCloseTo(8.0f, byLessThan(0.5f));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.public static 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.public static 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.public static Offset<Byte> byLessThan(Byte value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat((byte) 10).isCloseTo((byte) 11, byLessThan((byte) 2));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.public static Offset<Integer> byLessThan(Integer value)
Offset to use with strict isCloseTo assertions.
Typical usage :
assertThat(10).isCloseTo(12, byLessThan(1));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.public static Offset<Short> byLessThan(Short value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat((short) 10).isCloseTo((short) 11, byLessThan((short) 2));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.public static Offset<Long> byLessThan(Long value)
Offset to use with strict isCloseTo assertions.
Typical usage :
assertThat(5l).isCloseTo(7l, byLessThan(3l));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.public static 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.public static <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 propertyextractor@SafeVarargs public static <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.public static <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.@SafeVarargs public static <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.public static <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.public static <T> DoesNotHave<T> doesNotHave(Condition<? super T> condition)
DoesNotHaveT - the type of object the given condition accept.condition - the condition to inverse.public static <T> Not<T> not(Condition<? super T> condition)
NotT - the type of object the given condition accept.condition - the condition to inverse.public static <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.Filterspublic static <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);public static 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)public static 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)public static 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 matchpublic static 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.public static 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.public static 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.public static List<String> linesOf(File file)
file - the file.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.public static 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.public static 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.public static 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.public static 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.public static 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.public static List<String> linesOf(URL url)
url - the URL.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.public static 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.public static 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.public static 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 notpublic static 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:ssX, " +
"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.public static 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:ssX, " +
"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.public static 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:ssXyyyy-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-26public static <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 componentpublic static AbstractCharSequenceAssert<?,? extends CharSequence> assertThat(CharSequence actual)
CharSequenceAssertactual - the actual value.public static AbstractCharSequenceAssert<?,String> assertThat(String actual)
CharSequenceAssertfrom a Stringactual - the actual value.public static <ELEMENT> IterableAssert<ELEMENT> assertThat(Iterable<? extends ELEMENT> actual)
IterableAssertELEMENT - the type of elements.actual - the actual value.public static <ELEMENT> IterableAssert<ELEMENT> assertThat(Iterator<? extends ELEMENT> actual)
IterableAssertBe aware that calls to most methods on returned IterableAssert will consume Iterator so it won't be possible to iterate over it again. Calling multiple methods on returned IterableAssert is safe as Iterator's elements are cached by IterableAssert first time Iterator is consumed.
ELEMENT - the type of elements.actual - the actual value.public static <ELEMENT> ListAssert<ELEMENT> assertThat(List<? extends ELEMENT> actual)
ListAssertELEMENT - the type of elements.actual - the actual value.public static <ELEMENT> ListAssert<ELEMENT> assertThat(Stream<? extends ELEMENT> actual)
ListAssertStream.
Be aware that to create the returned ListAssert the given the Stream is consumed so it won't be
possible to use it again. Calling multiple methods on the returned ListAssert is safe as it only
interacts with the List built from the Stream.
ELEMENT - the type of elements.actual - the actual Stream value.public static ListAssert<Double> assertThat(DoubleStream actual)
ListAssertDoubleStream.
Be aware that to create the returned ListAssert the given the DoubleStream is consumed so it won't be
possible to use it again. Calling multiple methods on the returned ListAssert is safe as it only
interacts with the List built from the DoubleStream.
actual - the actual DoubleStream value.public static ListAssert<Long> assertThat(LongStream actual)
ListAssertLongStream.
Be aware that to create the returned ListAssert the given the LongStream is consumed so it won't be
possible to use it again. Calling multiple methods on the returned ListAssert is safe as it only
interacts with the List built from the LongStream.
actual - the actual LongStream value.public static ListAssert<Integer> assertThat(IntStream actual)
ListAssertIntStream.
Be aware that to create the returned ListAssert the given the IntStream is consumed so it won't be
possible to use it again. Calling multiple methods on the returned ListAssert is safe as it only
interacts with the List built from the IntStream.
actual - the actual IntStream value.public static AbstractPathAssert<?> assertThat(Path actual)
PathAssertactual - the path to testpublic static <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.public static <T extends Comparable<? super T>> AbstractComparableAssert<?,T> assertThat(T actual)
GenericComparableAssertT - the type of actual.actual - the actual value.public static <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.public static 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 usepublic static <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 Functionpublic static void useDefaultRepresentation()
StandardRepresentation to revert the effect of calling useRepresentation(Representation).Copyright © 2014–2018 AssertJ. All rights reserved.