All Superinterfaces:: InstanceOfAssertFactories

public interface WithAssertions extends InstanceOfAssertFactories

A unified entry point to all non-deprecated assertions from both the new Java 8 core API and the pre-Java 8 core API.

As a convenience, the methods are defined in an interface so that no static imports are necessary if the test class implements this interface.

Based on an idea by David Gageot :

http://blog.javabien.net/2014/04/23/what-if-assertj-used-java-8/

Author:: Alan Rothkopf

Field Summary

Fields inherited from interface org.assertj.core.api.InstanceOfAssertFactories
ARRAY, ARRAY_2D, ATOMIC_BOOLEAN, ATOMIC_INTEGER, ATOMIC_INTEGER_ARRAY, ATOMIC_INTEGER_FIELD_UPDATER, ATOMIC_LONG, ATOMIC_LONG_ARRAY, ATOMIC_LONG_FIELD_UPDATER, ATOMIC_MARKABLE_REFERENCE, ATOMIC_REFERENCE, ATOMIC_REFERENCE_ARRAY, ATOMIC_REFERENCE_FIELD_UPDATER, ATOMIC_STAMPED_REFERENCE, BIG_DECIMAL, BIG_INTEGER, BOOLEAN, BOOLEAN_2D_ARRAY, BOOLEAN_ARRAY, BYTE, BYTE_2D_ARRAY, BYTE_ARRAY, CHAR_2D_ARRAY, CHAR_ARRAY, CHAR_SEQUENCE, CHARACTER, CLASS, COLLECTION, COMPLETABLE_FUTURE, COMPLETION_STAGE, DATE, DOUBLE, DOUBLE_2D_ARRAY, DOUBLE_ARRAY, DOUBLE_PREDICATE, DOUBLE_STREAM, DURATION, FILE, FLOAT, FLOAT_2D_ARRAY, FLOAT_ARRAY, FUTURE, INPUT_STREAM, INSTANT, INT_2D_ARRAY, INT_ARRAY, INT_PREDICATE, INT_STREAM, INTEGER, ITERABLE, ITERATOR, LIST, LOCAL_DATE, LOCAL_DATE_TIME, LOCAL_TIME, LONG, LONG_2D_ARRAY, LONG_ADDER, LONG_ARRAY, LONG_PREDICATE, LONG_STREAM, MAP, MATCHER, OFFSET_DATE_TIME, OFFSET_TIME, OPTIONAL, OPTIONAL_DOUBLE, OPTIONAL_INT, OPTIONAL_LONG, PATH, PERIOD, PREDICATE, SET, SHORT, SHORT_2D_ARRAY, SHORT_ARRAY, SPLITERATOR, STREAM, STRING, STRING_BUFFER, STRING_BUILDER, TEMPORAL, THROWABLE, URI_TYPE, URL_TYPE, YEAR_MONTH, ZONED_DATE_TIME
Method Summary

Modifier and Type

Method

Description

default <T> Condition<T>

allOf(Iterable<? extends Condition<? super T>> conditions)

Creates a new AllOf

default <T> Condition<T>

allOf(Condition<? super T>... conditions)

Creates a new AllOf

default <T> ThrowingConsumer<T>

allOf(ThrowingConsumer<? super T>... consumers)

Create a new ThrowingConsumer that delegates the evaluation of the given consumers to AbstractAssert.satisfies(ThrowingConsumer[]).

default <T> Condition<T>

anyOf(Iterable<? extends Condition<? super T>> conditions)

Creates a new AnyOf

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> ThrowingConsumer<T>

anyOf(ThrowingConsumer<? super T>... consumers)

Create a new ThrowingConsumer that delegates the evaluation of the given consumers to AbstractAssert.satisfiesAnyOf(ThrowingConsumer[]).

default <T, ASSERT extends AbstractAssert<?, ?>> InstanceOfAssertFactory<T,ASSERT>

as(InstanceOfAssertFactory<T,ASSERT> assertFactory)

A syntax sugar to write fluent assertion with methods having an InstanceOfAssertFactory parameter.

default AbstractBooleanAssert<?>

assertThat(boolean actual)

Creates a new instance of BooleanAssert.

default AbstractBooleanArrayAssert<?>

assertThat(boolean[] actual)

Creates a new instance of BooleanArrayAssert.

default Boolean2DArrayAssert

assertThat(boolean[][] actual)

Creates a new instance of Boolean2DArrayAssert.

default AbstractByteAssert<?>

assertThat(byte actual)

Creates a new instance of ByteAssert.

default AbstractByteArrayAssert<?>

assertThat(byte[] actual)

Creates a new instance of ByteArrayAssert.

default Byte2DArrayAssert

assertThat(byte[][] actual)

Creates a new instance of Byte2DArrayAssert.

default AbstractCharacterAssert<?>

assertThat(char actual)

Creates a new instance of CharacterAssert.

default AbstractCharArrayAssert<?>

assertThat(char[] actual)

Creates a new instance of CharArrayAssert.

default Char2DArrayAssert

assertThat(char[][] actual)

Creates a new instance of Char2DArrayAssert.

default AbstractDoubleAssert<?>

assertThat(double actual)

Creates a new instance of DoubleAssert.

default AbstractDoubleArrayAssert<?>

assertThat(double[] actual)

Creates a new instance of DoubleArrayAssert.

default Double2DArrayAssert

assertThat(double[][] actual)

Creates a new instance of Double2DArrayAssert.

default AbstractFloatAssert<?>

assertThat(float actual)

Creates a new instance of FloatAssert.

default AbstractFloatArrayAssert<?>

assertThat(float[] actual)

Creates a new instance of FloatArrayAssert.

default Float2DArrayAssert

assertThat(float[][] actual)

Creates a new instance of Float2DArrayAssert.

default AbstractIntegerAssert<?>

assertThat(int actual)

Creates a new instance of IntegerAssert.

default AbstractIntArrayAssert<?>

assertThat(int[] actual)

Creates a new instance of IntArrayAssert.

default Int2DArrayAssert

assertThat(int[][] actual)

Creates a new instance of Int2DArrayAssert.

default AbstractLongAssert<?>

assertThat(long actual)

Creates a new instance of LongAssert.

default AbstractLongArrayAssert<?>

assertThat(long[] actual)

Creates a new instance of LongArrayAssert.

default Long2DArrayAssert

assertThat(long[][] actual)

Creates a new instance of Long2DArrayAssert.

default AbstractShortAssert<?>

assertThat(short actual)

Creates a new instance of ShortAssert.

default AbstractShortArrayAssert<?>

assertThat(short[] actual)

Creates a new instance of ShortArrayAssert.

default Short2DArrayAssert

assertThat(short[][] actual)

Creates a new instance of Short2DArrayAssert.

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)

Deprecated.
This was added to help creating type-specific assertions for the elements of an Iterable instance.

default AbstractFileAssert<?>

assertThat(File actual)

Creates a new instance of FileAssert.

default AbstractInputStreamAssert<?,? extends InputStream>

assertThat(InputStream actual)

Creates a new instance of InputStreamAssert.

default AbstractBooleanAssert<?>

assertThat(Boolean actual)

Creates a new instance of BooleanAssert.

default AbstractByteAssert<?>

assertThat(Byte actual)

Creates a new instance of ByteAssert.

default AbstractCharacterAssert<?>

assertThat(Character actual)

Creates a new instance of CharacterAssert.

default AbstractCharSequenceAssert<?,? extends CharSequence>

assertThat(CharSequence actual)

Creates a new instance of CharSequenceAssert.

default ClassAssert

assertThat(Class<?> actual)

Creates a new instance of ClassAssert.

default AbstractDoubleAssert<?>

assertThat(Double actual)

Creates a new instance of DoubleAssert.

default AbstractFloatAssert<?>

assertThat(Float actual)

Creates a new instance of FloatAssert.

default AbstractIntegerAssert<?>

assertThat(Integer actual)

Creates a new instance of IntegerAssert.

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)

Deprecated.
This was added to help creating type-specific assertions for the elements of an Iterable instance.

default <T> IterableAssert<T>

assertThat(Iterable<? extends T> actual)

Creates a new instance of IterableAssert.

default AbstractLongAssert<?>

assertThat(Long actual)

Creates a new instance of LongAssert.

default AbstractShortAssert<?>

assertThat(Short actual)

Creates a new instance of ShortAssert.

default AbstractStringAssert<?>

assertThat(String actual)

Creates a new instance of CharSequenceAssertfrom a String.

default AbstractCharSequenceAssert<?,? extends CharSequence>

assertThat(StringBuffer actual)

Creates a new instance of CharSequenceAssert from a StringBuffer.

default AbstractCharSequenceAssert<?,? extends CharSequence>

assertThat(StringBuilder actual)

Creates a new instance of CharSequenceAssert from a StringBuilder.

default AbstractBigDecimalAssert<?>

assertThat(BigDecimal actual)

Creates a new instance of BigDecimalAssert.

default AbstractBigIntegerAssert<?>

assertThat(BigInteger actual)

Creates a new instance of BigIntegerAssert.

default AbstractUriAssert<?>

assertThat(URI actual)

Creates a new instance of UriAssert.

default AbstractUrlAssert<?>

assertThat(URL actual)

Creates a new instance of UrlAssert.

default AbstractPathAssert<?>

assertThat(Path actual)

Creates a new instance of PathAssert

default AbstractDurationAssert<?>

assertThat(Duration actual)

Creates a new instance of DurationAssert.

default AbstractInstantAssert<?>

assertThat(Instant actual)

Creates a new instance of InstantAssert.

default AbstractLocalDateAssert<?>

assertThat(LocalDate localDate)

Creates a new instance of LocalDateAssert.

default AbstractLocalDateTimeAssert<?>

assertThat(LocalDateTime localDateTime)

Creates a new instance of LocalDateTimeAssert.

default AbstractLocalTimeAssert<?>

assertThat(LocalTime localTime)

Creates a new instance of LocalTimeAssert.

default AbstractOffsetDateTimeAssert<?>

assertThat(OffsetDateTime offsetDateTime)

Creates a new instance of OffsetTimeAssert.

default AbstractOffsetTimeAssert<?>

assertThat(OffsetTime offsetTime)

Creates a new instance of OffsetTimeAssert.

default AbstractPeriodAssert<?>

assertThat(Period actual)

Creates a new instance of PeriodAssert.

default AbstractYearMonthAssert<?>

assertThat(YearMonth yearMonth)

Creates a new instance of YearMonthAssert.

default AbstractZonedDateTimeAssert<?>

assertThat(ZonedDateTime actual)

Creates a new instance of ZonedDateTimeAssert.

default <E> AbstractCollectionAssert<?,Collection<? extends E>,E,ObjectAssert<E>>

assertThat(Collection<? extends E> actual)

Creates a new instance of CollectionAssert.

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> AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT>

assertThat(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)

Create assertion for AtomicReferenceFieldUpdater.

default <VALUE> AtomicStampedReferenceAssert<VALUE>

assertThat(AtomicStampedReference<VALUE> actual)

Create assertion for AtomicStampedReference.

default LongAdderAssert

assertThat(LongAdder actual)

Create assertion for LongAdder.

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 <RESULT> FutureAssert<RESULT>

assertThat(Future<RESULT> actual)

Create assertion for Future.

default AbstractDateAssert<?>

assertThat(Date actual)

Creates a new instance of DateAssert.

default DoublePredicateAssert

assertThat(DoublePredicate actual)

Create assertion for DoublePredicate.

default IntPredicateAssert

assertThat(IntPredicate actual)

Create assertion for IntPredicate.

default LongPredicateAssert

assertThat(LongPredicate actual)

Create assertion for LongPredicate.

default <T> PredicateAssert<T>

assertThat(Predicate<T> actual)

Create assertion for Predicate.

default <T> IteratorAssert<T>

assertThat(Iterator<? extends T> actual)

Creates a new instance of IteratorAssert.

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)

Deprecated.
This was added to help creating type-specific assertions for the elements of an List 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)

Deprecated.
This was added to help creating type-specific assertions for the elements of an List instance.

default <T> ListAssert<T>

assertThat(List<? extends T> actual)

Creates a new instance of ListAssert.

default <K, V> MapAssert<K,V>

assertThat(Map<K,V> actual)

Creates a new instance of MapAssert.

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 MatcherAssert

assertThat(Matcher matcher)

Create assertion for Matcher

default <ELEMENT> SpliteratorAssert<ELEMENT>

assertThat(Spliterator<ELEMENT> actual)

Creates a new instance of SpliteratorAssert.

default ListAssert<Double>

assertThat(DoubleStream actual)

Creates a new instance of ListAssert from the given DoubleStream.

default ListAssert<Integer>

assertThat(IntStream actual)

Creates a new instance of ListAssert from the given IntStream.

default ListAssert<Long>

assertThat(LongStream actual)

Creates a new instance of ListAssert from the given LongStream.

default <ELEMENT> ListAssert<ELEMENT>

assertThat(Stream<? extends ELEMENT> actual)

Creates a new instance of ListAssert from the given Stream.

default <T> T

assertThat(AssertProvider<T> component)

Delegates the creation of the Assert to the AssertProvider.assertThat() of the given component.

default <T extends AssertDelegateTarget> T

assertThat(T assertion)

Returns the given assertion.

default <T> ObjectArrayAssert<T>

assertThat(T[] actual)

Creates a new instance of ObjectArrayAssert.

default <T> Object2DArrayAssert<T>

assertThat(T[][] actual)

Creates a new instance of Object2DArrayAssert.

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 <E> AbstractCollectionAssert<?,Collection<? extends E>,E,ObjectAssert<E>>

assertThatCollection(Collection<? extends E> actual)

Creates a new instance of CollectionAssert.

default <T> AbstractUniversalComparableAssert<?,T>

assertThatComparable(Comparable<T> actual)

Creates a new instance of UniversalComparableAssert with standard comparison semantics.

default ThrowableTypeAssert<Exception>

assertThatException()

Alias for assertThatExceptionOfType(Class) for Exception.

default <T extends Throwable> ThrowableTypeAssert<T>

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<IndexOutOfBoundsException>

assertThatIndexOutOfBoundsException()

Alias for assertThatExceptionOfType(Class) for IndexOutOfBoundsException.

default ThrowableTypeAssert<IOException>

assertThatIOException()

Alias for assertThatExceptionOfType(Class) for IOException.

default <ELEMENT> IterableAssert<ELEMENT>

assertThatIterable(Iterable<? extends ELEMENT> actual)

Creates a new instance of IterableAssert.

default <ELEMENT> IteratorAssert<ELEMENT>

assertThatIterator(Iterator<? extends ELEMENT> actual)

Creates a new instance of IteratorAssert.

default <ELEMENT> ListAssert<ELEMENT>

assertThatList(List<? extends ELEMENT> actual)

Creates a new instance of ListAssert.

default NotThrownAssert

assertThatNoException()

Entry point to check that no exception of any type is thrown by a given throwingCallable.

default ThrowableTypeAssert<NullPointerException>

assertThatNullPointerException()

Alias for assertThatExceptionOfType(Class) for NullPointerException.

default <T> ObjectAssert<T>

assertThatObject(T actual)

Creates a new instance of ObjectAssert for any object.

default AbstractPathAssert<?>

assertThatPath(Path actual)

Creates a new instance of PathAssert

default <T> PredicateAssert<T>

assertThatPredicate(Predicate<T> actual)

Create assertion for Predicate.

default ThrowableTypeAssert<ReflectiveOperationException>

assertThatReflectiveOperationException()

Alias for assertThatExceptionOfType(Class) for ReflectiveOperationException.

default ThrowableTypeAssert<RuntimeException>

assertThatRuntimeException()

Alias for assertThatExceptionOfType(Class) for RuntimeException.

default <ELEMENT> ListAssert<ELEMENT>

assertThatStream(Stream<? extends ELEMENT> actual)

Creates a new instance of ListAssert from the given Stream.

default TemporalAssert

assertThatTemporal(Temporal temporal)

Creates a new instance of TemporalAssert.

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 <T> ObjectAssert<T>

assertWith(T actual, Consumer<T>... requirements)

Uses the given instance as the instance under test for all the assertions expressed as the passed Consumer.

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 TemporalUnitOffset

byLessThan(long value, TemporalUnit unit)

Assertions entry point for TemporalUnitOffset with strict less than condition to use with isCloseTo temporal 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 Offset<Short>

byLessThan(Short value)

Assertions entry point for Short Offset to use with isCloseTo assertions.

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 TemporalUnitOffset

byLessThan(Duration duration)

Assertions entry point for Duration with strict less than condition to use with isCloseTo temporal assertions.

default Exception

catchException(ThrowableAssert.ThrowingCallable throwingCallable)

Allows catching an instance of Exception.

default IllegalArgumentException

catchIllegalArgumentException(ThrowableAssert.ThrowingCallable throwingCallable)

Allows catching an instance of IllegalArgumentException.

default IllegalStateException

catchIllegalStateException(ThrowableAssert.ThrowingCallable throwingCallable)

Allows catching an instance of IllegalStateException.

default IndexOutOfBoundsException

catchIndexOutOfBoundsException(ThrowableAssert.ThrowingCallable throwingCallable)

Allows catching an instance of IndexOutOfBoundsException.

default IOException

catchIOException(ThrowableAssert.ThrowingCallable throwingCallable)

Allows catching an instance of IOException.

default NullPointerException

catchNullPointerException(ThrowableAssert.ThrowingCallable throwingCallable)

Allows catching an instance of NullPointerException.

default ReflectiveOperationException

catchReflectiveOperationException(ThrowableAssert.ThrowingCallable throwingCallable)

Allows catching an instance of ReflectiveOperationException.

default RuntimeException

catchRuntimeException(ThrowableAssert.ThrowingCallable throwingCallable)

Allows catching an instance of RuntimeException.

default Throwable

catchThrowable(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)

Allows to catch an Throwable more easily when used with Java 8 lambdas.

default <THROWABLE extends Throwable> THROWABLE

catchThrowableOfType(Class<THROWABLE> type, ThrowableAssert.ThrowingCallable shouldRaiseThrowable)

Allows catching a Throwable of a specific type.

default <THROWABLE extends Throwable> THROWABLE

catchThrowableOfType(ThrowableAssert.ThrowingCallable shouldRaiseThrowable, Class<THROWABLE> type)

Deprecated.
use catchThrowableOfType(Class, ThrowingCallable) instead.

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, String charsetName)

Loads the text content of a file, 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(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, String charsetName)

Loads the text content of a URL, 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 <T> DoesNotHave<T>

doesNotHave(Condition<? super T> condition)

Creates a new DoesNotHave.

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()

Throws an AssertionError with an empty message to be used in code like:

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

fail(Throwable realCause)

Throws an AssertionError 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) and AbstractObjectAssert.doesNotReturn(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, String charsetName)

Loads the text content of a file into a list of strings, 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(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, String charsetName)

Loads the text content of a URL into a list of strings, 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(Path path)

Loads the text content of a file at a given path into a list of strings with the default charset, each string corresponding to a line.

default List<String>

linesOf(Path path, String charsetName)

Loads the text content of a file at a given path into a list of strings, each string corresponding to a line.

default List<String>

linesOf(Path path, Charset charset)

Loads the text content of a file at a given path into a list of strings, each string corresponding to a line.

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 <T> Not<T>

not(Condition<? super T> condition)

Creates a new Not.

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(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 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 <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 IterableAssert#extracting(String) and ObjectArrayAssert#extracting(String) should be allowed to extract private fields, if not and they try it fails with exception.

static void

setDescriptionConsumer(Consumer<Description> descriptionConsumer)

All assertions description will be consumed by the given Consumer<Description> allowing for example to record them in a file.

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)

Sets the maximum number of elements to display in error messages for iterables, arrays and map .

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

setMaxStackTraceElementsDisplayed(int maxStackTraceElementsDisplayed)

Sets how many stacktrace elements are included in Throwable representation (by default this set to 3).

static void

setPrintAssertionsDescription(boolean printAssertionsDescription)

Enable/disable printing assertions description to the console (disabled by default).

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 TemporalUnitOffset

within(long value, TemporalUnit unit)

Assertions entry point for TemporalUnitOffset with less than or equal condition to use with isCloseTo temporal 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 Offset<Short>

within(Short value)

Assertions entry point for Short Offset to use with isCloseTo 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 TemporalUnitOffset

within(Duration duration)

Assertions entry point for Duration with less than or equal condition to use with isCloseTo temporal 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 Duration

withMarginOf(Duration allowedDifference)

Syntactic sugar method to use with AbstractDurationAssert.isCloseTo(Duration, Duration) assertion.

default Offset<Double>

withPrecision(Double value)

Assertions entry point for double Offset.

default Offset<Float>

withPrecision(Float value)

Assertions entry point for float Offset.

Method Details
- offset
  
  default Offset<Float> offset(Float value)
  Assertions entry point for float Offset.
  Typical usage :
  assertThat(8.2f).isCloseTo(8.0f, offset(0.2f));
  Parameters:
  
  value - the allowed offset
  
  Returns:
  
  the created Offset.
- offset
  
  default Offset<Double> offset(Double value)
  Assertions entry point for double Offset.
  Typical usage :
  assertThat(8.1).isEqualTo(8.0, offset(0.1));
  Parameters:
  
  value - the allowed offset
  
  Returns:
  
  the created Offset.
- entry
  
  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).
  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));
  Type Parameters:
  
  K - the type of keys in the map.
  
  V - the type of values in the map.
  
  Parameters:
  
  key - the key of the entry to create.
  
  value - the value of the entry to create.
  
  Returns:
  
  the created MapEntry.
- fail
  
  @Contract("_ -> fail") default <T> T fail(String failureMessage)
  
  Throws an AssertionError with the given message.
  
  Type Parameters:
  
  T - dummy return value type
  
  Parameters:
  
  failureMessage - error message.
  
  Returns:
  
  nothing, it's just to be used in doSomething(optional.orElseGet(() -> fail("boom")));.
  
  Throws:
  
  AssertionError - with the given message.
- fail
  
  @Contract(" -> fail") default <T> T fail()
  Throws an AssertionError with an empty message to be used in code like:
  doSomething(optional.orElseGet(() -> fail()));
  Type Parameters:
  
  T - dummy return value type
  
  Returns:
  
  nothing, it's just to be used in doSomething(optional.orElseGet(() -> fail()));.
  
  Throws:
  
  AssertionError - with an empty message.
  
  Since:
  
  3.26.0
- fail
  
  @Contract("_, _ -> fail") default <T> T fail(String failureMessage, Object... args)
  
  Throws an AssertionError with the given message built as String.format(String, Object...).
  
  Type Parameters:
  
  T - dummy return value type
  
  Parameters:
  
  failureMessage - error message.
  
  args - Arguments referenced by the format specifiers in the format string.
  
  Returns:
  
  nothing, it's just to be used in doSomething(optional.orElseGet(() -> fail("b%s", "oom")));.
  
  Throws:
  
  AssertionError - with the given built message.
  
  Since:
  
  3.9.0
- fail
  
  @Contract("_, _ -> fail") default <T> T fail(String failureMessage, Throwable realCause)
  
  Throws an AssertionError with the given message and with the Throwable that caused the failure.
  
  Type Parameters:
  
  T - dummy return value type
  
  Parameters:
  
  failureMessage - the description of the failed assertion. It can be null.
  
  realCause - cause of the error.
  
  Returns:
  
  nothing, it's just to be used in doSomething(optional.orElseGet(() -> fail("boom", cause)));.
  
  Throws:
  
  AssertionError - with the given message and with the Throwable that caused the failure.
- fail
  
  @Contract("_ -> fail") default <T> T fail(Throwable realCause)
  
  Throws an AssertionError with the Throwable that caused the failure.
  
  Type Parameters:
  
  T - dummy return value type
  
  Parameters:
  
  realCause - cause of the error.
  
  Returns:
  
  nothing, it's just to be used in doSomething(optional.orElseGet(() -> fail(cause)));.
  
  Throws:
  
  AssertionError - with the Throwable that caused the failure.
- not
  
  default <T> Not<T> not(Condition<? super T> condition)
  
  Creates a new Not.
  
  Type Parameters:
  
  T - the type of object the given condition accept.
  
  Parameters:
  
  condition - the condition to inverse.
  
  Returns:
  
  The Not condition created.
- allOf
  
  default <T> Condition<T> allOf(Iterable<? extends Condition<? super T>> conditions)
  
  Creates a new AllOf
  
  Type Parameters:
  
  T - the type of object the given condition accept.
  
  Parameters:
  
  conditions - the conditions to evaluate.
  
  Returns:
  
  the created AllOf.
  
  Throws:
  
  NullPointerException - if the given iterable is null.
  
  NullPointerException - if any of the elements in the given iterable is null.
- allOf
  
  default <T> Condition<T> allOf(Condition<? super T>... conditions)
  
  Creates a new AllOf
  
  Type Parameters:
  
  T - the type of object the given condition accept.
  
  Parameters:
  
  conditions - the conditions to evaluate.
  
  Returns:
  
  the created AllOf.
  
  Throws:
  
  NullPointerException - if the given array is null.
  
  NullPointerException - if any of the elements in the given array is null.
- allOf
  
  default <T> ThrowingConsumer<T> allOf(ThrowingConsumer<? super T>... consumers)
  
  Create a new ThrowingConsumer that delegates the evaluation of the given consumers to AbstractAssert.satisfies(ThrowingConsumer[]).
  
  Type Parameters:
  
  T - the type of object the given consumers accept
  
  Parameters:
  
  consumers - the consumers to evaluate
  
  Returns:
  
  the ThrowingConsumer instance
  
  Since:
  
  3.25.0
- assertThat
  
  default <T> ObjectArrayAssert<T> assertThat(T[] actual)
  
  Creates a new instance of ObjectArrayAssert.
  
  Type Parameters:
  
  T - the actual's elements type.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <T> Object2DArrayAssert<T> assertThat(T[][] actual)
  
  Creates a new instance of Object2DArrayAssert.
  
  Type Parameters:
  
  T - the actual's elements type.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.17.0
- assertThat
  
  default <T extends AssertDelegateTarget> T assertThat(T assertion)
  Returns the given assertion. This method improves code readability by surrounding the given assertion with 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(); } }
  As MyButtonAssert implements AssertDelegateTarget, you can use 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(); }
  Type Parameters:
  
  T - the generic type of the user-defined assert.
  
  Parameters:
  
  assertion - the assertion to return.
  
  Returns:
  
  the given assertion.
- assertThat
  
  default <K, V> MapAssert<K,V> assertThat(Map<K,V> actual)
  
  Creates a new instance of MapAssert.
  Returned type is MapAssert as it overrides method to annotate them with SafeVarargs avoiding annoying warnings.
  
  Type Parameters:
  
  K - the type of keys in the map.
  
  V - the type of values in the map.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractShortAssert<?> assertThat(short actual)
  
  Creates a new instance of ShortAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractLongAssert<?> assertThat(long actual)
  
  Creates a new instance of LongAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractLongAssert<?> assertThat(Long actual)
  
  Creates a new instance of LongAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractLongArrayAssert<?> assertThat(long[] actual)
  
  Creates a new instance of LongArrayAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default Long2DArrayAssert assertThat(long[][] actual)
  
  Creates a new instance of Long2DArrayAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.17.0
- assertThat
  
  default <T> ObjectAssert<T> assertThat(T actual)
  
  Creates a new instance of ObjectAssert.
  
  Type Parameters:
  
  T - the type of the actual value.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractStringAssert<?> assertThat(String actual)
  
  Creates a new instance of CharSequenceAssertfrom a String.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractDateAssert<?> assertThat(Date actual)
  
  Creates a new instance of DateAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <T extends Throwable> AbstractThrowableAssert<?,T> assertThat(T actual)
  
  Creates a new instance of ThrowableAssert.
  
  Type Parameters:
  
  T - the type of the actual throwable.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created ThrowableAssert.
- assertThat
  
  default AbstractBigDecimalAssert<?> assertThat(BigDecimal actual)
  
  Creates a new instance of BigDecimalAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractBigIntegerAssert<?> assertThat(BigInteger actual)
  
  Creates a new instance of BigIntegerAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  2.7.0 / 3.7.0
- assertThat
  
  default AtomicBooleanAssert assertThat(AtomicBoolean actual)
  
  Create assertion for AtomicBoolean.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AtomicIntegerAssert assertThat(AtomicInteger actual)
  
  Create assertion for AtomicInteger.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AtomicIntegerArrayAssert assertThat(AtomicIntegerArray actual)
  
  Create int[] assertion for AtomicIntegerArray.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT> assertThat(AtomicIntegerFieldUpdater<OBJECT> actual)
  
  Create assertion for AtomicIntegerFieldUpdater.
  
  Type Parameters:
  
  OBJECT - the type of the object holding the updatable field.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default LongAdderAssert assertThat(LongAdder actual)
  
  Create assertion for LongAdder.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AtomicLongAssert assertThat(AtomicLong actual)
  
  Create assertion for AtomicLong.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AtomicLongArrayAssert assertThat(AtomicLongArray actual)
  
  Create assertion for AtomicLongArray.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT> assertThat(AtomicLongFieldUpdater<OBJECT> actual)
  
  Create assertion for AtomicLongFieldUpdater.
  
  Type Parameters:
  
  OBJECT - the type of the object holding the updatable field.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <VALUE> AtomicReferenceAssert<VALUE> assertThat(AtomicReference<VALUE> actual)
  
  Create assertion for AtomicReference.
  
  Type Parameters:
  
  VALUE - the type of the value contained in the AtomicReference.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <ELEMENT> AtomicReferenceArrayAssert<ELEMENT> assertThat(AtomicReferenceArray<ELEMENT> actual)
  
  Create assertion for AtomicReferenceArray.
  
  Type Parameters:
  
  ELEMENT - the type of the value contained in the AtomicReferenceArray.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <FIELD, OBJECT> AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT> assertThat(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)
  
  Create assertion for AtomicReferenceFieldUpdater.
  
  Type Parameters:
  
  FIELD - the type of the field which gets updated by the AtomicReferenceFieldUpdater.
  
  OBJECT - the type of the object holding the updatable field.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <VALUE> AtomicMarkableReferenceAssert<VALUE> assertThat(AtomicMarkableReference<VALUE> actual)
  
  Create assertion for AtomicMarkableReference.
  
  Type Parameters:
  
  VALUE - the type of the value contained in the AtomicMarkableReference.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <VALUE> AtomicStampedReferenceAssert<VALUE> assertThat(AtomicStampedReference<VALUE> actual)
  
  Create assertion for AtomicStampedReference.
  
  Type Parameters:
  
  VALUE - the type of the value contained in the AtomicStampedReference.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractCharSequenceAssert<?,? extends CharSequence> assertThat(CharSequence actual)
  
  Creates a new instance of CharSequenceAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractCharSequenceAssert<?,? extends CharSequence> assertThat(StringBuilder actual)
  
  Creates a new instance of CharSequenceAssert from a StringBuilder.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.11.0
- assertThat
  
  default AbstractCharSequenceAssert<?,? extends CharSequence> assertThat(StringBuffer actual)
  
  Creates a new instance of CharSequenceAssert from a StringBuffer.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.11.0
- assertThat
  
  default AbstractShortArrayAssert<?> assertThat(short[] actual)
  
  Creates a new instance of ShortArrayAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default Short2DArrayAssert assertThat(short[][] actual)
  
  Creates a new instance of Short2DArrayAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.17.0
- assertThat
  
  default AbstractShortAssert<?> assertThat(Short actual)
  
  Creates a new instance of ShortAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default ClassAssert assertThat(Class<?> actual)
  
  Creates a new instance of ClassAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractCharacterAssert<?> assertThat(Character actual)
  
  Creates a new instance of CharacterAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractCharArrayAssert<?> assertThat(char[] actual)
  
  Creates a new instance of CharArrayAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default Char2DArrayAssert assertThat(char[][] actual)
  
  Creates a new instance of Char2DArrayAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.17.0
- assertThat
  
  default AbstractCharacterAssert<?> assertThat(char actual)
  
  Creates a new instance of CharacterAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <T extends Comparable<? super T>> AbstractComparableAssert<?,T> assertThat(T actual)
  
  Creates a new instance of GenericComparableAssert with standard comparison semantics.
  
  Type Parameters:
  
  T - the type of actual.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThatComparable
  
  default <T> AbstractUniversalComparableAssert<?,T> assertThatComparable(Comparable<T> actual)
  
  Creates a new instance of UniversalComparableAssert with standard comparison semantics.
  Use this over assertThat(Comparable) in case of ambiguous method resolution when the object under test implements several interfaces Assertj provides assertThat for.
  
  Type Parameters:
  
  T - the type of actual.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.23.0
- assertThat
  
  default <T> IterableAssert<T> assertThat(Iterable<? extends T> actual)
  
  Creates a new instance of IterableAssert.
  
  Type Parameters:
  
  T - the type of elements.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThatIterable
  
  default <ELEMENT> IterableAssert<ELEMENT> assertThatIterable(Iterable<? extends ELEMENT> actual)
  
  Creates a new instance of IterableAssert.
  Use this over assertThat(Iterable) in case of ambiguous method resolution when the object under test implements several interfaces Assertj provides assertThat for.
  
  Type Parameters:
  
  ELEMENT - the type of elements.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.23.0
- assertThat
  
  @Deprecated 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)
  Deprecated.
  This was added to help creating type-specific assertions for the elements of an Iterable instance.
  Deprecated way:
  Iterable<String> hobbits = Set.of("frodo", "sam", "Pippin"); assertThat(hobbits, StringAssert::new).first() .startsWith("fro") .endsWith("do");
  However, there is a better way with InstanceOfAssertFactory and the corresponding first(InstanceOfAssertFactory).
  New way:
  assertThat(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING .startsWith("fro") .endsWith("do");
  The main advantage of the latter is easier discoverability and the use of InstanceOfAssertFactory which is the preferred way to create type-specific assertions in AssertJ API.
  Creates a new instance of FactoryBasedNavigableIterableAssert allowing to navigate to any Iterable element in order to perform assertions on it.
  Navigational methods provided:
  
  first()
  
  last()
  
  element(index)
  
  elements(int...)
  
  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");
  Type Parameters:
  
  ACTUAL - The actual type
  
  ELEMENT - The actual elements type
  
  ELEMENT_ASSERT - The actual elements AbstractAssert type
  
  Parameters:
  
  actual - the actual value.
  
  assertFactory - the factory used to create the elements assert instance.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <T> IteratorAssert<T> assertThat(Iterator<? extends T> actual)
  Creates a new instance of 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
  Type Parameters:
  
  T - the type of elements.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThatIterator
  
  default <ELEMENT> IteratorAssert<ELEMENT> assertThatIterator(Iterator<? extends ELEMENT> actual)
  
  Creates a new instance of IteratorAssert.
  Use this over assertThat(Iterator) in case of ambiguous method resolution when the object under test implements several interfaces Assertj provides assertThat for.
  
  Type Parameters:
  
  ELEMENT - the type of elements.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.23.0
- assertThat
  
  @Deprecated 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)
  Deprecated.
  This was added to help creating type-specific assertions for the elements of an Iterable instance.
  Deprecated way:
  Iterable<String> hobbits = Set.of("frodo", "sam", "Pippin"); assertThat(hobbits, StringAssert.class).first() .startsWith("fro") .endsWith("do");
  However, there is a better way with InstanceOfAssertFactory and the corresponding first(InstanceOfAssertFactory).
  New way:
  assertThat(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING .startsWith("fro") .endsWith("do");
  The main advantage of the latter is easier discoverability and the use of InstanceOfAssertFactory which is the preferred way to create type-specific assertions in AssertJ API.
  Creates a new instance of ClassBasedNavigableIterableAssert allowing to navigate to any Iterable element in order to perform assertions on it.
  Navigational methods provided:
  
  first()
  
  last()
  
  element(index)
  
  elements(int...)
  
  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");
  Type Parameters:
  
  ACTUAL - The actual type
  
  ELEMENT - The actual elements type
  
  ELEMENT_ASSERT - The actual elements AbstractAssert type
  
  Parameters:
  
  actual - the actual value.
  
  assertClass - the class used to create the elements assert instance.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractBooleanAssert<?> assertThat(Boolean actual)
  
  Creates a new instance of BooleanAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractBooleanArrayAssert<?> assertThat(boolean[] actual)
  
  Creates a new instance of BooleanArrayAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default Boolean2DArrayAssert assertThat(boolean[][] actual)
  
  Creates a new instance of Boolean2DArrayAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.17.0
- assertThat
  
  default AbstractByteAssert<?> assertThat(byte actual)
  
  Creates a new instance of ByteAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractByteAssert<?> assertThat(Byte actual)
  
  Creates a new instance of ByteAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractByteArrayAssert<?> assertThat(byte[] actual)
  
  Creates a new instance of ByteArrayAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default Byte2DArrayAssert assertThat(byte[][] actual)
  
  Creates a new instance of Byte2DArrayAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.17.0
- assertThat
  
  default AbstractBooleanAssert<?> assertThat(boolean actual)
  
  Creates a new instance of BooleanAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractFloatAssert<?> assertThat(float actual)
  
  Creates a new instance of FloatAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractInputStreamAssert<?,? extends InputStream> assertThat(InputStream actual)
  
  Creates a new instance of InputStreamAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractFileAssert<?> assertThat(File actual)
  
  Creates a new instance of FileAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <RESULT> FutureAssert<RESULT> assertThat(Future<RESULT> actual)
  
  Create assertion for Future.
  
  Type Parameters:
  
  RESULT - the type of the value contained in the Future.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.7.0
- assertThat
  
  default AbstractPathAssert<?> assertThat(Path actual)
  
  Creates a new instance of PathAssert
  
  Parameters:
  
  actual - the path to test
  
  Returns:
  
  the created assertion object
- assertThatPath
  
  default AbstractPathAssert<?> assertThatPath(Path actual)
  
  Creates a new instance of PathAssert
  Use this over assertThat(Path) in case of ambiguous method resolution when the object under test implements several interfaces Assertj provides assertThat for.
  
  Parameters:
  
  actual - the path to test
  
  Returns:
  
  the created assertion object
  
  Since:
  
  3.23.0
- assertThat
  
  default AbstractIntArrayAssert<?> assertThat(int[] actual)
  
  Creates a new instance of IntArrayAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default Int2DArrayAssert assertThat(int[][] actual)
  
  Creates a new instance of Int2DArrayAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.17.0
- assertThat
  
  default AbstractFloatAssert<?> assertThat(Float actual)
  
  Creates a new instance of FloatAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default Float2DArrayAssert assertThat(float[][] actual)
  
  Creates a new instance of Float2DArrayAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.17.0
- assertThat
  
  default AbstractIntegerAssert<?> assertThat(int actual)
  
  Creates a new instance of IntegerAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractFloatArrayAssert<?> assertThat(float[] actual)
  
  Creates a new instance of FloatArrayAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractIntegerAssert<?> assertThat(Integer actual)
  
  Creates a new instance of IntegerAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractDoubleAssert<?> assertThat(double actual)
  
  Creates a new instance of DoubleAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractDoubleAssert<?> assertThat(Double actual)
  
  Creates a new instance of DoubleAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <E> AbstractCollectionAssert<?,Collection<? extends E>,E,ObjectAssert<E>> assertThat(Collection<? extends E> actual)
  
  Creates a new instance of CollectionAssert.
  
  Type Parameters:
  
  E - the type of elements.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.21.0
- assertThatCollection
  
  default <E> AbstractCollectionAssert<?,Collection<? extends E>,E,ObjectAssert<E>> assertThatCollection(Collection<? extends E> actual)
  
  Creates a new instance of CollectionAssert.
  Use this over assertThat(Collection) in case of ambiguous method resolution when the object under test implements several interfaces Assertj provides assertThat for.
  
  Type Parameters:
  
  E - the type of elements.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.23.0
- assertThat
  
  default <T> ListAssert<T> assertThat(List<? extends T> actual)
  
  Creates a new instance of ListAssert.
  
  Type Parameters:
  
  T - the type of elements.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThatList
  
  default <ELEMENT> ListAssert<ELEMENT> assertThatList(List<? extends ELEMENT> actual)
  
  Creates a new instance of ListAssert.
  Use this over assertThat(List) in case of ambiguous method resolution when the object under test implements several interfaces Assertj provides assertThat for.
  
  Type Parameters:
  
  ELEMENT - the type of elements.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.23.0
- assertThat
  
  @Deprecated 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)
  Deprecated.
  This was added to help creating type-specific assertions for the elements of an List instance.
  Deprecated way:
  List<String> hobbits = List.of("frodo", "sam", "Pippin"); assertThat(hobbits, StringAssert.class).first() .startsWith("fro") .endsWith("do");
  However, there is a better way with InstanceOfAssertFactory and the corresponding first(InstanceOfAssertFactory).
  New way:
  assertThat(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING .startsWith("fro") .endsWith("do");
  The main advantage of the latter is easier discoverability and the use of InstanceOfAssertFactory which is the preferred way to create type-specific assertions in AssertJ API.
  Creates a new instance of ClassBasedNavigableListAssert allowing to navigate to any List element in order to perform assertions on it.
  Navigational methods provided:
  
  first()
  
  last()
  
  element(index)
  
  elements(int...)
  
  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");
  Type Parameters:
  
  ELEMENT - The actual elements type
  
  ACTUAL - The actual type
  
  ELEMENT_ASSERT - The actual elements AbstractAssert type
  
  Parameters:
  
  actual - the actual value.
  
  assertClass - the class used to create the elements assert instance.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  @Deprecated 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)
  Deprecated.
  This was added to help creating type-specific assertions for the elements of an List instance.
  Deprecated way:
  List<String> hobbits = List.of("frodo", "sam", "Pippin"); assertThat(hobbits, StringAssert::new).first() .startsWith("fro") .endsWith("do");
  However, there is a better way with InstanceOfAssertFactory and the corresponding first(InstanceOfAssertFactory).
  New way:
  assertThat(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING .startsWith("fro") .endsWith("do");
  The main advantage of the latter is easier discoverability and the use of InstanceOfAssertFactory which is the preferred way to create type-specific assertions in AssertJ API.
  Creates a new instance of FactoryBasedNavigableListAssert allowing to navigate to any List element in order to perform assertions on it.
  Navigational methods provided:
  
  first()
  
  last()
  
  element(index)
  
  elements(int...)
  
  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");
  Type Parameters:
  
  ACTUAL - The actual type
  
  ELEMENT - The actual elements type
  
  ELEMENT_ASSERT - The actual elements AbstractAssert type
  
  Parameters:
  
  actual - the actual value.
  
  assertFactory - the factory used to create the elements assert instance.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <ELEMENT> ListAssert<ELEMENT> assertThat(Stream<? extends ELEMENT> actual)
  Creates a new instance of ListAssert from the given Stream.
  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);
  Type Parameters:
  
  ELEMENT - the type of elements.
  
  Parameters:
  
  actual - the actual Stream value.
  
  Returns:
  
  the created assertion object.
- assertThatStream
  
  default <ELEMENT> ListAssert<ELEMENT> assertThatStream(Stream<? extends ELEMENT> actual)
  Creates a new instance of ListAssert from the given Stream.
  Use this over assertThat(Stream) in case of ambiguous method resolution when the object under test implements several interfaces Assertj provides assertThat for.
  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);
  Type Parameters:
  
  ELEMENT - the type of elements.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.23.0
- assertThat
  
  default ListAssert<Double> assertThat(DoubleStream actual)
  Creates a new instance of ListAssert from the given DoubleStream.
  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);
  Parameters:
  
  actual - the actual DoubleStream value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default ListAssert<Long> assertThat(LongStream actual)
  Creates a new instance of ListAssert from the given LongStream.
  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);
  Parameters:
  
  actual - the actual LongStream value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default ListAssert<Integer> assertThat(IntStream actual)
  Creates a new instance of ListAssert from the given IntStream.
  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);
  Parameters:
  
  actual - the actual IntStream value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractDoubleArrayAssert<?> assertThat(double[] actual)
  
  Creates a new instance of DoubleArrayAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default Double2DArrayAssert assertThat(double[][] actual)
  
  Creates a new instance of Double2DArrayAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.17.0
- extractProperty
  
  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).
  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");
  Parameters:
  
  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").
  
  Returns:
  
  the created Properties.
  
  Throws:
  
  NullPointerException - if the given property name is null.
  
  IllegalArgumentException - if the given property name is empty.
- extractProperty
  
  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).
  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");
  Type Parameters:
  
  T - the type of value to extract.
  
  Parameters:
  
  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 extract
  
  Returns:
  
  the created Properties.
  
  Throws:
  
  NullPointerException - if the given property name is null.
  
  IllegalArgumentException - if the given property name is empty.
- tuple
  
  default Tuple tuple(Object... values)
  
  Utility method to build nicely a Tuple when working with AbstractIterableAssert.extracting(String...) or AbstractObjectArrayAssert.extracting(String...)
  
  Parameters:
  
  values - the values stored in the Tuple
  
  Returns:
  
  the built Tuple
- atIndex
  
  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).
  Typical usage :
  List<Ring> elvesRings = newArrayList(vilya, nenya, narya); assertThat(elvesRings).contains(vilya, atIndex(0)).contains(nenya, atIndex(1)).contains(narya, atIndex(2));
  Parameters:
  
  index - the value of the index.
  
  Returns:
  
  the created Index.
  
  Throws:
  
  IllegalArgumentException - if the given value is negative.
- within
  
  default Offset<Double> within(Double value)
  Alias for offset(Double) to use with isCloseTo assertions.
  Typical usage :
  assertThat(8.1).isCloseTo(8.0, within(0.1));
  Parameters:
  
  value - the value of the offset.
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
- within
  
  default Offset<BigDecimal> within(BigDecimal value)
  Assertions entry point for BigDecimal Offset to use with isCloseTo assertions.
  Typical usage :
  assertThat(BigDecimal.TEN).isCloseTo(new BigDecimal("10.5"), within(BigDecimal.ONE));
  Parameters:
  
  value - the value of the offset.
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
- within
  
  default Offset<Float> within(Float value)
  Alias for offset(Float) to use with isCloseTo assertions.
  Typical usage :
  assertThat(8.2f).isCloseTo(8.0f, within(0.2f));
  Parameters:
  
  value - the value of the offset.
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
- withPrecision
  
  default Offset<Double> withPrecision(Double value)
  Assertions entry point for double Offset.
  Typical usage :
  assertThat(8.1).isEqualTo(8.0, offset(0.1));
  Parameters:
  
  value - the allowed offset
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- withPrecision
  
  default Offset<Float> withPrecision(Float value)
  Assertions entry point for float Offset.
  Typical usage :
  assertThat(8.2f).isCloseTo(8.0f, offset(0.2f));
  Parameters:
  
  value - the allowed offset
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- within
  
  default Offset<BigInteger> within(BigInteger value)
  Assertions entry point for BigInteger Offset to use with isCloseTo assertions.
  Typical usage :
  assertThat(BigInteger.TEN).isCloseTo(new BigInteger("11"), within(new BigInteger("2")));
  Parameters:
  
  value - the value of the offset.
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- within
  
  default Offset<Byte> within(Byte value)
  Assertions entry point for Byte Offset to use with isCloseTo assertions.
  Typical usage :
  assertThat((byte) 10).isCloseTo((byte) 11, within((byte) 1));
  Parameters:
  
  value - the value of the offset.
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- within
  
  default Offset<Integer> within(Integer value)
  Assertions entry point for Integer Offset to use with isCloseTo assertions.
  Typical usage :
  assertThat(10).isCloseTo(11, within(1));
  Parameters:
  
  value - the value of the offset.
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- within
  
  default Offset<Short> within(Short value)
  Assertions entry point for Short Offset to use with isCloseTo assertions.
  Typical usage :
  assertThat(10).isCloseTo(11, within(1));
  Parameters:
  
  value - the value of the offset.
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- within
  
  default Offset<Long> within(Long value)
  Assertions entry point for Long Offset to use with isCloseTo assertions.
  Typical usage :
  assertThat(5l).isCloseTo(7l, within(2l));
  Parameters:
  
  value - the value of the offset.
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- within
  
  default TemporalUnitOffset within(long value, TemporalUnit unit)
  Assertions entry point for TemporalUnitOffset 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));
  Parameters:
  
  value - the allowed offset
  
  unit - the TemporalUnit of the offset
  
  Returns:
  
  the created Offset.
  
  Since:
  
  3.9.0
- within
  
  default TemporalUnitOffset within(Duration duration)
  Assertions entry point for Duration 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(Duration.ofMinutes(5)));
  Parameters:
  
  duration - the Duration of the offset
  
  Returns:
  
  the created Offset.
  
  Since:
  
  3.27.0
  
  See Also:
  
  byLessThan(Duration)
- withMarginOf
  
  default Duration withMarginOf(Duration allowedDifference)
  Syntactic sugar method to use with AbstractDurationAssert.isCloseTo(Duration, Duration) assertion.
  Example:
  assertThat(Duration.ofMinutes(2)).isCloseTo(Duration.ofMinutes(3), withMarginOf(Duration.ofMinutes(1)));
  Parameters:
  
  allowedDifference - the allowed difference Duration.
  
  Returns:
  
  the given value.
- withinPercentage
  
  default Percentage withinPercentage(Double value)
  Assertions entry point for Double Percentage to use with isCloseTo assertions for percentages.
  Typical usage :
  assertThat(11.0).isCloseTo(10.0, withinPercentage(10.0));
  Parameters:
  
  value - the required precision percentage
  
  Returns:
  
  the created Percentage.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- withinPercentage
  
  default Percentage withinPercentage(Integer value)
  Assertions entry point for Integer Percentage to use with isCloseTo assertions for percentages.
  Typical usage :
  assertThat(11).isCloseTo(10, withinPercentage(10));
  Parameters:
  
  value - the required precision percentage
  
  Returns:
  
  the created Percentage.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- withinPercentage
  
  default Percentage withinPercentage(Long value)
  Assertions entry point for Long Percentage to use with isCloseTo assertions for percentages.
  Typical usage :
  assertThat(11L).isCloseTo(10L, withinPercentage(10L));
  Parameters:
  
  value - the required precision percentage
  
  Returns:
  
  the created Percentage.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- byLessThan
  
  default Offset<Double> byLessThan(Double value)
  Alias for offset(Double) to use with isCloseTo assertions.
  Typical usage :
  assertThat(8.1).isCloseTo(8.0, byLessThan(0.1));
  Parameters:
  
  value - the value of the offset.
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- byLessThan
  
  default Offset<Float> byLessThan(Float value)
  Alias for offset(Float) to use with isCloseTo assertions.
  Typical usage :
  assertThat(8.2f).isCloseTo(8.0f, byLessThan(0.2f));
  Parameters:
  
  value - the value of the offset.
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- byLessThan
  
  default Offset<BigDecimal> byLessThan(BigDecimal value)
  Assertions entry point for BigDecimal Offset to use with isCloseTo assertions.
  Typical usage :
  assertThat(BigDecimal.TEN).isCloseTo(new BigDecimal("10.5"), byLessThan(BigDecimal.ONE));
  Parameters:
  
  value - the value of the offset.
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- byLessThan
  
  default Offset<BigInteger> byLessThan(BigInteger value)
  Assertions entry point for BigInteger Offset to use with isCloseTo assertions.
  Typical usage :
  assertThat(BigInteger.TEN).isCloseTo(new BigInteger("11"), byLessThan(new BigInteger("2")));
  Parameters:
  
  value - the value of the offset.
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- byLessThan
  
  default Offset<Byte> byLessThan(Byte value)
  Assertions entry point for Byte Offset to use with isCloseTo assertions.
  Typical usage :
  assertThat((byte) 10).isCloseTo((byte) 11, byLessThan((byte) 1));
  Parameters:
  
  value - the value of the offset.
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- byLessThan
  
  default Offset<Integer> byLessThan(Integer value)
  Assertions entry point for Integer Offset to use with isCloseTo assertions.
  Typical usage :
  assertThat(10).isCloseTo(11, byLessThan(1));
  Parameters:
  
  value - the value of the offset.
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- byLessThan
  
  default Offset<Short> byLessThan(Short value)
  Assertions entry point for Short Offset to use with isCloseTo assertions.
  Typical usage :
  assertThat(10).isCloseTo(11, byLessThan(1));
  Parameters:
  
  value - the value of the offset.
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- byLessThan
  
  default Offset<Long> byLessThan(Long value)
  Assertions entry point for Long Offset to use with isCloseTo assertions.
  Typical usage :
  assertThat(5l).isCloseTo(7l, byLessThan(2l));
  Parameters:
  
  value - the value of the offset.
  
  Returns:
  
  the created Offset.
  
  Throws:
  
  NullPointerException - if the given value is null.
  
  IllegalArgumentException - if the given value is negative.
  
  Since:
  
  3.9.0
- byLessThan
  
  default TemporalUnitOffset byLessThan(long value, TemporalUnit unit)
  Assertions entry point for 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));
  Parameters:
  
  value - the value of the offset.
  
  unit - the TemporalUnit of the offset.
  
  Returns:
  
  the created Offset.
  
  Since:
  
  3.9.0
- byLessThan
  
  default TemporalUnitOffset byLessThan(Duration duration)
  Assertions entry point for Duration 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(Duration.ofMinutes(5)));
  Parameters:
  
  duration - the Duration of the offset.
  
  Returns:
  
  the created Offset.
  
  Since:
  
  3.27.0
  
  See Also:
  
  within(Duration)
- from
  
  default <F, T> Function<F,T> from(Function<F,T> extractor)
  A syntax sugar to write fluent assertion using AbstractObjectAssert.returns(Object, Function) and AbstractObjectAssert.doesNotReturn(Object, Function).
  Example:
  Jedi yoda = new Jedi("Yoda", "Green"); assertThat(yoda).returns("Yoda", from(Jedi::getName)) .returns(2.4, from(Jedi::getHeight)) .doesNotReturn(null, from(Jedi::getWeight));
  Type Parameters:
  
  F - Type of test subject
  
  T - Type of the property under the assertion
  
  Parameters:
  
  extractor - A function to extract test subject's property
  
  Returns:
  
  same instance of extractor
  
  Since:
  
  3.9.0
- as
  
  default <T, ASSERT extends AbstractAssert<?, ?>> InstanceOfAssertFactory<T,ASSERT> as(InstanceOfAssertFactory<T,ASSERT> assertFactory)
  A syntax sugar to write fluent assertion with methods having an InstanceOfAssertFactory parameter.
  Example:
  Jedi yoda = new Jedi("Yoda", "Green"); assertThat(yoda).extracting(Jedi::getName, as(InstanceOfAssertFactories.STRING)) .startsWith("Yo");
  Type Parameters:
  
  T - the type to use for the cast.
  
  ASSERT - the type of the resulting Assert
  
  Parameters:
  
  assertFactory - the factory which verifies the type and creates the new Assert
  
  Returns:
  
  same instance of assertFactory
  
  Since:
  
  3.14.0
  
  See Also:
  
  Assertions.as(InstanceOfAssertFactory)
- anyOf
  
  default <T> Condition<T> anyOf(Iterable<? extends Condition<? super T>> conditions)
  
  Creates a new AnyOf
  
  Type Parameters:
  
  T - the type of object the given condition accept.
  
  Parameters:
  
  conditions - the conditions to evaluate.
  
  Returns:
  
  the created AnyOf.
  
  Throws:
  
  NullPointerException - if the given iterable is null.
  
  NullPointerException - if any of the elements in the given iterable is null.
- anyOf
  
  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).
  Typical usage (jedi and sith are Condition) :
  assertThat("Vader").is(anyOf(jedi, sith));
  Type Parameters:
  
  T - the type of object the given condition accept.
  
  Parameters:
  
  conditions - the conditions to evaluate.
  
  Returns:
  
  the created AnyOf.
- anyOf
  
  default <T> ThrowingConsumer<T> anyOf(ThrowingConsumer<? super T>... consumers)
  
  Create a new ThrowingConsumer that delegates the evaluation of the given consumers to AbstractAssert.satisfiesAnyOf(ThrowingConsumer[]).
  
  Type Parameters:
  
  T - the type of object the given consumers accept
  
  Parameters:
  
  consumers - the consumers to evaluate
  
  Returns:
  
  the ThrowingConsumer instance
  
  Since:
  
  3.25.0
- doesNotHave
  
  default <T> DoesNotHave<T> doesNotHave(Condition<? super T> condition)
  
  Creates a new DoesNotHave.
  
  Type Parameters:
  
  T - the type of object the given condition accept.
  
  Parameters:
  
  condition - the condition to inverse.
  
  Returns:
  
  The DoesNotHave condition created.
- contentOf
  
  default String contentOf(File file, String charsetName)
  
  Loads the text content of a file, so that it can be passed to 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).
  
  Parameters:
  
  file - the file.
  
  charsetName - the name of the character set to use.
  
  Returns:
  
  the content of the file.
  
  Throws:
  
  IllegalArgumentException - if the given character set is not supported on this platform.
  
  UncheckedIOException - if an I/O exception occurs.
- contentOf
  
  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).
  Note that this will load the entire file in memory; for larger files, there might be a more efficient alternative with assertThat(File).
  
  Parameters:
  
  file - the file.
  
  Returns:
  
  the content of the file.
  
  Throws:
  
  UncheckedIOException - if an I/O exception occurs.
- contentOf
  
  default String contentOf(File file, Charset charset)
  
  Loads the text content of a file, so that it can be passed to 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).
  
  Parameters:
  
  file - the file.
  
  charset - the character set to use.
  
  Returns:
  
  the content of the file.
  
  Throws:
  
  NullPointerException - if the given charset is null.
  
  UncheckedIOException - if an I/O exception occurs.
- linesOf
  
  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. The line endings are either \n, \r or \r\n.
  
  Parameters:
  
  file - the file.
  
  Returns:
  
  the content of the file.
  
  Throws:
  
  NullPointerException - if the given charset is null.
  
  UncheckedIOException - if an I/O exception occurs.
- linesOf
  
  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. The line endings are either \n, \r or \r\n.
  
  Parameters:
  
  file - the file.
  
  charsetName - the name of the character set to use.
  
  Returns:
  
  the content of the file.
  
  Throws:
  
  NullPointerException - if the given charset is null.
  
  UncheckedIOException - if an I/O exception occurs.
- linesOf
  
  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. The line endings are either \n, \r or \r\n.
  
  Parameters:
  
  file - the file.
  
  charset - the character set to use.
  
  Returns:
  
  the content of the file.
  
  Throws:
  
  NullPointerException - if the given charset is null.
  
  UncheckedIOException - if an I/O exception occurs.
- linesOf
  
  default List<String> linesOf(Path path)
  
  Loads the text content of a file at a given path into a list of strings with the default charset, each string corresponding to a line. The line endings are either \n, \r or \r\n.
  
  Parameters:
  
  path - the path.
  
  Returns:
  
  the content of the file at the given path.
  
  Throws:
  
  NullPointerException - if the given charset is null.
  
  UncheckedIOException - if an I/O exception occurs.
  
  Since:
  
  3.23.0
- linesOf
  
  default List<String> linesOf(Path path, String charsetName)
  
  Loads the text content of a file at a given path into a list of strings, each string corresponding to a line. The line endings are either \n, \r or \r\n.
  
  Parameters:
  
  path - the file.
  
  charsetName - the name of the character set to use.
  
  Returns:
  
  the content of the file at the given path.
  
  Throws:
  
  NullPointerException - if the given charset is null.
  
  UncheckedIOException - if an I/O exception occurs.
  
  Since:
  
  3.23.0
- linesOf
  
  default List<String> linesOf(Path path, Charset charset)
  
  Loads the text content of a file at a given path into a list of strings, each string corresponding to a line. The line endings are either \n, \r or \r\n.
  
  Parameters:
  
  path - the path.
  
  charset - the character set to use.
  
  Returns:
  
  the content of the file at the given path.
  
  Throws:
  
  NullPointerException - if the given charset is null.
  
  UncheckedIOException - if an I/O exception occurs.
  
  Since:
  
  3.23.0
- setRemoveAssertJRelatedElementsFromStackTrace
  
  default void setRemoveAssertJRelatedElementsFromStackTrace(boolean removeAssertJRelatedElementsFromStackTrace)
  
  Sets whether we remove elements related to AssertJ from assertion error stack trace.
  
  Parameters:
  
  removeAssertJRelatedElementsFromStackTrace - flag.
- failBecauseExceptionWasNotThrown
  
  @Contract("_ -> fail") 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.
  Assertions.shouldHaveThrown(Class) can be used as a replacement.
  
  Type Parameters:
  
  T - dummy return value type
  
  Parameters:
  
  throwableClass - the Throwable class that was expected to be thrown.
  
  Returns:
  
  nothing, it's just to be used in doSomething(optional.orElseGet(() -> failBecauseExceptionWasNotThrown(IOException.class)));.
  
  Throws:
  
  AssertionError - with a message explaining that a Throwable of given class was expected to be thrown but had not been.
- shouldHaveThrown
  
  @Contract("_ -> fail") 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.
  
  Type Parameters:
  
  T - dummy return value type
  
  Parameters:
  
  throwableClass - the Throwable class that was expected to be thrown.
  
  Returns:
  
  nothing, it's just to be used in doSomething(optional.orElseGet(() -> shouldHaveThrown(IOException.class)));.
  
  Throws:
  
  AssertionError - with a message explaining that a Throwable of given class was expected to be thrown but had not been.
  
  Since:
  
  3.9.0
- setMaxLengthForSingleLineDescription
  
  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.
  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"]
  whereas this array is formatted on multiple lines (one element per line)
  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)"]
  Parameters:
  
  maxLengthForSingleLineDescription - the maximum length for an iterable/array to be displayed on one line
  
  Since:
  
  3.9.0
- setMaxElementsForPrinting
  
  default void setMaxElementsForPrinting(int maxElementsForPrinting)
  Sets the maximum number of elements to display in error messages for iterables, arrays and map .
  Example with a value of 4.
  The following array will be formatted entirely as it's length is <= 4:
  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"]
  whereas for this 6 elements array, only the first and last two elements are displayed (4 in total):
  String[] greatBooks = array("A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice", "Guards! Guards!", "The Lies of Locke Lamora", "Aux Ombres d’Abyme"); // formatted as: ["A Game of Thrones", "The Lord of the Rings", ... "The Lies of Locke Lamora", "Aux Ombres d’Abyme"]
  Parameters:
  
  maxElementsForPrinting - the maximum elements that would be printed for iterables, arrays and maps.
  
  Since:
  
  3.9.0
- setMaxStackTraceElementsDisplayed
  
  default void setMaxStackTraceElementsDisplayed(int maxStackTraceElementsDisplayed)
  Sets how many stacktrace elements are included in Throwable representation (by default this set to 3).
  Examples:
  static class Test1 { static void boom() { Test2.boom2(); } static class Test2 { static void boom2() { throw new RuntimeException(); } } }
  Test1.boom() exception should be represented like this in error messages:
  java.lang.RuntimeException at org.assertj.core.presentation.Test1$Test2.boom2(StandardRepresentation_throwable_format_Test.java:35) at org.assertj.core.presentation.Test1.boom(StandardRepresentation_throwable_format_Test.java:40);java.lang.RuntimeException at org.assertj.core.presentation.Test1.lambda$1(StandardRepresentation_throwable_format_Test.java:63)org.assertj.core.util.Throwables_Description_Test$test1$test2.exception_layer_2(Throwables_Description_Test.java:24) ...(69 remaining lines not displayed - this can be changed with Assertions.setMaxStackTraceElementsDisplayed)org.assertj.core.util.Throwables_Description_Test$test1.exception_layer_1(Throwables_Description_Test.java:30)
  Parameters:
  
  maxStackTraceElementsDisplayed - the maximum number of lines for a stacktrace to be displayed on one throw.
  
  Since:
  
  3.19.0
  
  See Also:
  
  Configuration
- setPrintAssertionsDescription
  
  static void setPrintAssertionsDescription(boolean printAssertionsDescription)
  
  Enable/disable printing assertions description to the console (disabled by default).
  The printed assertions description include all the successful assertions description and respectively the first failed one for standard assertions and all failed ones for soft assertions.
  If you want to process the description differently, create a Consumer<Description> and register it with setDescriptionConsumer(Consumer).
  
  Parameters:
  
  printAssertionsDescription - whether to print assertions description.
  
  Since:
  
  3.17.0
- setDescriptionConsumer
  
  static void setDescriptionConsumer(Consumer<Description> descriptionConsumer)
  
  All assertions description will be consumed by the given Consumer<Description> allowing for example to record them in a file.
  The consumed descriptions include all the successful assertions description and respectively the first failed one for standard assertions and all failed ones for soft assertions.
  
  Parameters:
  
  descriptionConsumer - the Description consumer
  
  Since:
  
  3.17.0
- setAllowExtractingPrivateFields
  
  default void setAllowExtractingPrivateFields(boolean allowExtractingPrivateFields)
  
  Globally sets whether IterableAssert#extracting(String) and ObjectArrayAssert#extracting(String) should be allowed to extract private fields, if not and they try it fails with exception.
  
  Parameters:
  
  allowExtractingPrivateFields - allow private fields extraction. Default true.
- setAllowComparingPrivateFields
  
  default void setAllowComparingPrivateFields(boolean allowComparingPrivateFields)
  Globally sets whether the use of private fields is allowed for comparison. The following (incomplete) list of methods will be impacted by this change :
  
  AbstractIterableAssert.usingElementComparatorOnFields(java.lang.String...)
  
  AbstractObjectAssert.isEqualToComparingFieldByField(Object)
  
  If the value is false and these methods try to compare private fields, it will fail with an exception.
  Parameters:
  
  allowComparingPrivateFields - allow private fields comparison. Default true.
  
  Since:
  
  3.9.0
- setExtractBareNamePropertyMethods
  
  default void setExtractBareNamePropertyMethods(boolean barenamePropertyMethods)
  
  Globally sets whether the extractor considers bare-named property methods like String name(). Defaults to enabled.
  
  Parameters:
  
  barenamePropertyMethods - whether bare-named property methods are found
- setLenientDateParsing
  
  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).
  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 here
  To revert to default strict date parsing, call setLenientDateParsing(false).
  Parameters:
  
  value - whether lenient parsing mode should be enabled or not
  
  Since:
  
  3.9.0
- registerCustomDateFormat
  
  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).
  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");
  Parameters:
  
  userCustomDateFormat - the new Date format used for String based Date assertions.
- registerCustomDateFormat
  
  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).
  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");
  Parameters:
  
  userCustomDateFormatPattern - the new Date format pattern used for String based Date assertions.
- useDefaultDateFormatsOnly
  
  default void useDefaultDateFormatsOnly()
  Remove all registered custom date formats => use only the defaults date formats to parse string as date.
  Beware that the default formats are expressed in the current local timezone.
  Defaults date format are:
  
  yyyy-MM-dd'T'HH:mm:ss.SSS
  
  yyyy-MM-dd HH:mm:ss.SSS (for Timestamp String representation support)
  
  yyyy-MM-dd'T'HH:mm:ss
  
  yyyy-MM-dd
  
  Example of valid string date representations:
  
  2003-04-26T03:01:02.999
  
  2003-04-26 03:01:02.999
  
  2003-04-26T13:01:02
  
  2003-04-26
- assertThat
  
  default AbstractZonedDateTimeAssert<?> assertThat(ZonedDateTime actual)
  
  Creates a new instance of ZonedDateTimeAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <RESULT> CompletableFutureAssert<RESULT> assertThat(CompletableFuture<RESULT> future)
  
  Create assertion for CompletableFuture.
  
  Type Parameters:
  
  RESULT - the type of the value contained in the CompletableFuture.
  
  Parameters:
  
  future - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <RESULT> CompletableFutureAssert<RESULT> assertThat(CompletionStage<RESULT> completionStage)
  
  Create assertion for 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.
  
  Type Parameters:
  
  RESULT - the type of the value contained in the CompletionStage.
  
  Parameters:
  
  completionStage - the actual CompletionStage.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <VALUE> OptionalAssert<VALUE> assertThat(Optional<VALUE> optional)
  
  Create assertion for Optional.
  
  Type Parameters:
  
  VALUE - the type of the value contained in the Optional.
  
  Parameters:
  
  optional - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default OptionalDoubleAssert assertThat(OptionalDouble optional)
  
  Create assertion for OptionalDouble.
  
  Parameters:
  
  optional - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default MatcherAssert assertThat(Matcher matcher)
  
  Create assertion for Matcher
  
  Parameters:
  
  matcher - the actual matcher.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default OptionalIntAssert assertThat(OptionalInt optional)
  
  Create assertion for OptionalInt.
  
  Parameters:
  
  optional - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default OptionalLongAssert assertThat(OptionalLong optional)
  
  Create assertion for OptionalLong.
  
  Parameters:
  
  optional - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThatTemporal
  
  default TemporalAssert assertThatTemporal(Temporal temporal)
  
  Creates a new instance of TemporalAssert.
  
  Parameters:
  
  temporal - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.26.1
- assertThat
  
  default AbstractLocalDateTimeAssert<?> assertThat(LocalDateTime localDateTime)
  
  Creates a new instance of LocalDateTimeAssert.
  
  Parameters:
  
  localDateTime - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractLocalDateAssert<?> assertThat(LocalDate localDate)
  
  Creates a new instance of LocalDateAssert.
  
  Parameters:
  
  localDate - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractYearMonthAssert<?> assertThat(YearMonth yearMonth)
  
  Creates a new instance of YearMonthAssert.
  
  Parameters:
  
  yearMonth - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.26.0
- assertThat
  
  default AbstractLocalTimeAssert<?> assertThat(LocalTime localTime)
  
  Creates a new instance of LocalTimeAssert.
  
  Parameters:
  
  localTime - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractInstantAssert<?> assertThat(Instant actual)
  
  Creates a new instance of InstantAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.7.0
- assertThat
  
  default AbstractDurationAssert<?> assertThat(Duration actual)
  
  Creates a new instance of DurationAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.15.0
- assertThat
  
  default AbstractPeriodAssert<?> assertThat(Period actual)
  
  Creates a new instance of PeriodAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.17.0
- assertThat
  
  default AbstractOffsetTimeAssert<?> assertThat(OffsetTime offsetTime)
  
  Creates a new instance of OffsetTimeAssert.
  
  Parameters:
  
  offsetTime - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractOffsetDateTimeAssert<?> assertThat(OffsetDateTime offsetDateTime)
  
  Creates a new instance of OffsetTimeAssert.
  
  Parameters:
  
  offsetDateTime - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThatThrownBy
  
  default AbstractThrowableAssert<?,? extends Throwable> assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
  Allows to capture and then assert on a Throwable (easier done with lambdas).
  Example :
  @Test public void testException() { assertThatThrownBy(() -> { throw new Exception("boom!") }).isInstanceOf(Exception.class) .hasMessageContaining("boom"); }
  If the provided 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.
  To use a test description, use catchThrowable(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);
  Alternatively you can also use assertThatCode(ThrowingCallable) for the test description provided with as(String, Object...) to always be honored.
  Parameters:
  
  shouldRaiseThrowable - The ThrowableAssert.ThrowingCallable or lambda with the code that should raise the throwable.
  
  Returns:
  
  the created ThrowableAssert.
- assertThatThrownBy
  
  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...).
  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"); }
  If the provided 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);
  Parameters:
  
  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.
  
  Returns:
  
  the created ThrowableAssert.
  
  Since:
  
  3.9.0
- assertThatCode
  
  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.
  Example :
  
  ThrowingCallable callable = () -> { throw new Exception("boom!"); }; // assertion succeeds assertThatCode(callable).isInstanceOf(Exception.class) .hasMessageContaining("boom"); // assertion fails assertThatCode(callable).doesNotThrowAnyException();
  If the provided 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.
  To use a test description, use catchThrowable(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 :(
  Parameters:
  
  shouldRaiseOrNotThrowable - The ThrowableAssert.ThrowingCallable or lambda with the code that should raise the throwable.
  
  Returns:
  
  The captured exception or null if none was raised by the callable.
  
  Since:
  
  3.7.0
- assertThatObject
  
  default <T> ObjectAssert<T> assertThatObject(T actual)
  Creates a new instance of ObjectAssert for any object.
  This overload is useful, when an overloaded method of assertThat(...) takes precedence over the generic assertThat(Object).
  
  Example:
  Cast necessary because assertThat(List) "forgets" actual type:
  assertThat(new LinkedList<>(asList("abc"))).matches(list -> ((Deque<String>) list).getFirst().equals("abc"));
  No cast needed, but also no additional list assertions:
  assertThatObject(new LinkedList<>(asList("abc"))).matches(list -> list.getFirst().equals("abc"));
  Type Parameters:
  
  T - the type of the actual value.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.12.0
- assertWith
  
  default <T> ObjectAssert<T> assertWith(T actual, Consumer<T>... requirements)
  Uses the given instance as the instance under test for all the assertions expressed as the passed Consumer.
  This is useful to avoid repeating getting the instance to test, a bit like a with block which turns the target into the equivalent of this (as in Groovy for example).
  Example:
  assertWith(team.getPlayers().get(0).getStats(), stats -> assertThat(stats.pointPerGame).isGreaterThan(25.7), stats -> assertThat(stats.assistsPerGame).isGreaterThan(7.2), stats -> assertThat(stats.reboundsPerGame).isBetween(9, 12) );
  
  assertWith is variation of AbstractAssert.satisfies(Consumer[]) hopefully easier to find for some users.
  Type Parameters:
  
  T - the type of the actual value.
  
  Parameters:
  
  actual - the actual value.
  
  requirements - to assert on the actual object - must not be null.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.20.0
- catchThrowable
  
  default Throwable catchThrowable(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
  Allows to catch an 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"); }
  Parameters:
  
  shouldRaiseThrowable - The lambda with the code that should raise the exception.
  
  Returns:
  
  The captured exception or null if none was raised by the callable.
  
  See Also:
  
  catchThrowableOfType(Class, ThrowingCallable)
- catchThrowableOfType
  
  @Deprecated default <THROWABLE extends Throwable> THROWABLE catchThrowableOfType(ThrowableAssert.ThrowingCallable shouldRaiseThrowable, Class<THROWABLE> type)
  
  Deprecated.
  use catchThrowableOfType(Class, ThrowingCallable) instead.
  Allows catching a 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);
  Type Parameters:
  
  THROWABLE - the Throwable type.
  
  Parameters:
  
  shouldRaiseThrowable - The lambda with the code that should raise the exception.
  
  type - The type of exception that the code is expected to raise.
  
  Returns:
  
  The captured exception or null if none was raised by the callable.
  
  Since:
  
  3.9.0
  
  See Also:
  
  catchThrowable(ThrowingCallable)
- catchThrowableOfType
  
  default <THROWABLE extends Throwable> THROWABLE catchThrowableOfType(Class<THROWABLE> type, ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
  Allows catching a 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(RuntimeException.class, () -> { throw new CustomParseException("boom!", 1, 5); });
  Type Parameters:
  
  THROWABLE - the Throwable type.
  
  Parameters:
  
  type - The type of exception that the code is expected to raise.
  
  shouldRaiseThrowable - The lambda with the code that should raise the exception.
  
  Returns:
  
  The captured exception or null if none was raised by the callable.
  
  Since:
  
  3.26.0
  
  See Also:
  
  catchThrowable(ThrowingCallable)
- catchException
  
  default Exception catchException(ThrowableAssert.ThrowingCallable throwingCallable)
  Allows catching an instance of Exception.
  A call is made to catchThrowable(ThrowingCallable), if no exception is thrown it returns null otherwise it checks that the caught Throwable is of type Exception and casts it making it convenient to perform subtype-specific assertions on it.
  Example:
  Exception exception = catchException(() -> {throw new Exception("boom!");}); // assertions succeed assertThat(exception).hasMessage("boom!"); // succeeds as catchException returns null when the code does not throw any exceptions assertThat(catchException(() -> {})).isNull(); // fails as the thrown instance is not an Exception catchException(() -> {throw new Throwable("boom!");});
  Parameters:
  
  throwingCallable - The lambda with the code that should raise the exception.
  
  Returns:
  
  The captured exception or null if none was raised by the callable.
  
  Since:
  
  3.22.0
  
  See Also:
  
  catchThrowable(ThrowingCallable)
- catchRuntimeException
  
  default RuntimeException catchRuntimeException(ThrowableAssert.ThrowingCallable throwingCallable)
  Allows catching an instance of RuntimeException.
  A call is made to catchThrowable(ThrowingCallable), if no exception is thrown it returns null otherwise it checks that the caught Throwable is of type RuntimeException and casts it making it convenient to perform subtype-specific assertions on it.
  Example:
  RuntimeException runtimeException = catchRuntimeException(() -> {throw new RuntimeException("boom!");}); // assertions succeed assertThat(runtimeException).hasMessage("boom!"); // succeeds as catchRuntimeException returns null when the code does not throw any exceptions assertThat(catchRuntimeException(() -> {})).isNull(); // fails as the thrown instance is not a RuntimeException catchRuntimeException(() -> {throw new Exception("boom!");});
  Parameters:
  
  throwingCallable - The lambda with the code that should raise the exception.
  
  Returns:
  
  The captured exception or null if none was raised by the callable.
  
  Since:
  
  3.22.0
  
  See Also:
  
  catchThrowable(ThrowingCallable)
- catchNullPointerException
  
  default NullPointerException catchNullPointerException(ThrowableAssert.ThrowingCallable throwingCallable)
  Allows catching an instance of NullPointerException.
  A call is made to catchThrowable(ThrowingCallable), if no exception is thrown it returns null otherwise it checks that the caught Throwable is of type RuntimeException and casts it making it convenient to perform subtype-specific assertions on it.
  Example:
  NullPointerException nullPointerException = catchNullPointerException(() -> {throw new NullPointerException("boom!");}); // assertions succeed assertThat(nullPointerException).hasMessage("boom!"); // succeeds as catchNullPointerException returns null when the code does not throw any exceptions assertThat(catchNullPointerException(() -> {})).isNull(); // fails as the thrown instance is not a NullPointerException catchNullPointerException(() -> {throw new Exception("boom!");});
  Parameters:
  
  throwingCallable - The lambda with the code that should raise the exception.
  
  Returns:
  
  The captured exception or null if none was raised by the callable.
  
  Since:
  
  3.22.0
  
  See Also:
  
  catchThrowable(ThrowingCallable)
- catchIllegalArgumentException
  
  default IllegalArgumentException catchIllegalArgumentException(ThrowableAssert.ThrowingCallable throwingCallable)
  Allows catching an instance of IllegalArgumentException.
  A call is made to catchThrowable(ThrowingCallable), if no exception is thrown it returns null otherwise it checks that the caught Throwable is of type IllegalArgumentException and casts it making it convenient to perform subtype-specific assertions on it.
  Example:
  IllegalArgumentException illegalArgumentException = catchIllegalArgumentException(() -> {throw new IllegalArgumentException("boom!");}); // assertions succeed assertThat(illegalArgumentException).hasMessage("boom!"); // succeeds as catchNullPointerException returns null when the code does not throw any exceptions assertThat(catchIllegalArgumentException(() -> {})).isNull(); // fails as the thrown instance is not an IllegalArgumentException catchIllegalArgumentException(() -> {throw new Exception("boom!");});
  Parameters:
  
  throwingCallable - The lambda with the code that should raise the exception.
  
  Returns:
  
  The captured exception or null if none was raised by the callable.
  
  Since:
  
  3.22.0
  
  See Also:
  
  catchThrowable(ThrowingCallable)
- catchIOException
  
  default IOException catchIOException(ThrowableAssert.ThrowingCallable throwingCallable)
  Allows catching an instance of IOException.
  A call is made to catchThrowable(ThrowingCallable), if no exception is thrown it returns null otherwise it checks that the caught Throwable is of type IOException and casts it making it convenient to perform subtype-specific assertions on it.
  Example:
  IOException iOException = catchIOException(() -> {throw new IOException("boom!");}); // assertions succeed assertThat(iOException).hasMessage("boom!"); // succeeds as catchIOException returns null when the code does not throw any exceptions assertThat(catchIOException(() -> {})).isNull(); // fails as the thrown instance is not an IOException catchIOException(() -> {throw new Exception("boom!");});
  Parameters:
  
  throwingCallable - The lambda with the code that should raise the exception.
  
  Returns:
  
  The captured exception or null if none was raised by the callable.
  
  Since:
  
  3.22.0
  
  See Also:
  
  catchThrowable(ThrowingCallable)
- catchReflectiveOperationException
  
  default ReflectiveOperationException catchReflectiveOperationException(ThrowableAssert.ThrowingCallable throwingCallable)
  Allows catching an instance of ReflectiveOperationException.
  A call is made to catchThrowable(ThrowingCallable), if no exception is thrown it returns null otherwise it checks that the caught Throwable is of type ReflectiveOperationException and casts it making it convenient to perform subtype-specific assertions on it.
  Example:
  ReflectiveOperationException reflectiveOperationException = catchReflectiveOperationException(() -> {throw new ReflectiveOperationException("boom!");}); // assertions succeed assertThat(reflectiveOperationException).hasMessage("boom!"); // succeeds as catchReflectiveOperationException returns null when the code does not throw any exceptions assertThat(catchReflectiveOperationException(() -> {})).isNull(); // fails as the thrown instance is not an IOException catchReflectiveOperationException(() -> {throw new Exception("boom!");});
  Parameters:
  
  throwingCallable - The lambda with the code that should raise the exception.
  
  Returns:
  
  The captured exception or null if none was raised by the callable.
  
  Since:
  
  3.22.0
  
  See Also:
  
  catchThrowable(ThrowingCallable)
- catchIllegalStateException
  
  default IllegalStateException catchIllegalStateException(ThrowableAssert.ThrowingCallable throwingCallable)
  Allows catching an instance of IllegalStateException.
  A call is made to catchThrowable(ThrowingCallable), if no exception is thrown it returns null otherwise it checks that the caught Throwable is of type IllegalStateException and casts it making it convenient to perform subtype-specific assertions on it.
  Example:
  IllegalStateException illegalStateException = catchIllegalStateException(() -> {throw new IllegalStateException("boom!");}); // assertions succeed assertThat(illegalStateException).hasMessage("boom!"); // succeeds as catchReflectiveOperationException returns null when the code does not throw any exceptions assertThat(catchIllegalStateException(() -> {})).isNull(); // fails as the thrown instance is not an IOException catchIllegalStateException(() -> {throw new Exception("boom!");});
  Parameters:
  
  throwingCallable - The lambda with the code that should raise the exception.
  
  Returns:
  
  The captured exception or null if none was raised by the callable.
  
  Since:
  
  3.22.0
  
  See Also:
  
  catchThrowable(ThrowingCallable)
- catchIndexOutOfBoundsException
  
  default IndexOutOfBoundsException catchIndexOutOfBoundsException(ThrowableAssert.ThrowingCallable throwingCallable)
  Allows catching an instance of IndexOutOfBoundsException.
  A call is made to catchThrowable(ThrowingCallable), if no exception is thrown it returns null otherwise it checks that the caught Throwable is of type IndexOutOfBoundsException and casts it making it convenient to perform subtype-specific assertions on it.
  Example:
  IndexOutOfBoundsException indexOutOfBoundsException = catchIndexOutOfBoundsException(() -> {throw new IndexOutOfBoundsException("boom!");}); // assertions succeed assertThat(indexOutOfBoundsException).hasMessage("boom!"); // succeeds as catchIndexOutOfBoundsException returns null when the code does not throw any exceptions assertThat(catchIndexOutOfBoundsException(() -> {})).isNull(); // fails as the thrown instance is not an IOException catchIndexOutOfBoundsException(() -> {throw new Exception("boom!");});
  Parameters:
  
  throwingCallable - The lambda with the code that should raise the exception.
  
  Returns:
  
  The captured exception or null if none was raised by the callable.
  
  Since:
  
  3.22.0
  
  See Also:
  
  catchThrowable(ThrowingCallable)
- assertThatExceptionOfType
  
  default <T extends Throwable> ThrowableTypeAssert<T> 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.
  Example:
  assertThatExceptionOfType(IOException.class) .isThrownBy(() -> { throw new IOException("boom!"); }) .withMessage("boom!");
  This method is more or less the same of assertThatThrownBy(ThrowingCallable) but in a more natural way.
  Type Parameters:
  
  T - the exception type.
  
  Parameters:
  
  exceptionType - the exception type class.
  
  Returns:
  
  the created ThrowableTypeAssert.
- assertThatNoException
  
  default NotThrownAssert assertThatNoException()
  Entry point to check that no exception of any type is thrown by a given throwingCallable.
  Example:
  assertThatNoException().isThrownBy(() -> { System.out.println("OK"); });
  This method is more or less the same of assertThatCode(...).doesNotThrowAnyException(); but in a more natural way.
  Returns:
  
  the created NotThrownAssert.
  
  Since:
  
  3.17.0
- assertThatNullPointerException
  
  default ThrowableTypeAssert<NullPointerException> assertThatNullPointerException()
  
  Alias for assertThatExceptionOfType(Class) for NullPointerException.
  
  Returns:
  
  the created ThrowableTypeAssert.
  
  Since:
  
  3.9.0
- assertThatIllegalArgumentException
  
  default ThrowableTypeAssert<IllegalArgumentException> assertThatIllegalArgumentException()
  
  Alias for assertThatExceptionOfType(Class) for IllegalArgumentException.
  
  Returns:
  
  the created ThrowableTypeAssert.
  
  Since:
  
  3.9.0
- assertThatIOException
  
  default ThrowableTypeAssert<IOException> assertThatIOException()
  
  Alias for assertThatExceptionOfType(Class) for IOException.
  
  Returns:
  
  the created ThrowableTypeAssert.
  
  Since:
  
  3.9.0
- assertThatIllegalStateException
  
  default ThrowableTypeAssert<IllegalStateException> assertThatIllegalStateException()
  
  Alias for assertThatExceptionOfType(Class) for IllegalStateException.
  
  Returns:
  
  the created ThrowableTypeAssert.
  
  Since:
  
  3.9.0
- assertThatException
  
  default ThrowableTypeAssert<Exception> assertThatException()
  
  Alias for assertThatExceptionOfType(Class) for Exception.
  
  Returns:
  
  the created ThrowableTypeAssert.
  
  Since:
  
  3.23.0
- assertThatIndexOutOfBoundsException
  
  default ThrowableTypeAssert<IndexOutOfBoundsException> assertThatIndexOutOfBoundsException()
  
  Alias for assertThatExceptionOfType(Class) for IndexOutOfBoundsException.
  
  Returns:
  
  the created ThrowableTypeAssert.
  
  Since:
  
  3.23.0
- assertThatReflectiveOperationException
  
  default ThrowableTypeAssert<ReflectiveOperationException> assertThatReflectiveOperationException()
  
  Alias for assertThatExceptionOfType(Class) for ReflectiveOperationException.
  
  Returns:
  
  the created ThrowableTypeAssert.
  
  Since:
  
  3.23.0
- assertThatRuntimeException
  
  default ThrowableTypeAssert<RuntimeException> assertThatRuntimeException()
  
  Alias for assertThatExceptionOfType(Class) for RuntimeException.
  
  Returns:
  
  the created ThrowableTypeAssert.
  
  Since:
  
  3.23.0
- assertThat
  
  default <T> PredicateAssert<T> assertThat(Predicate<T> actual)
  
  Create assertion for Predicate.
  
  Type Parameters:
  
  T - the type of the value contained in the Predicate.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThatPredicate
  
  default <T> PredicateAssert<T> assertThatPredicate(Predicate<T> actual)
  
  Create assertion for Predicate.
  Use this over assertThat(Iterable) in case of ambiguous method resolution when the object under test implements several interfaces Assertj provides assertThat for.
  
  Type Parameters:
  
  T - the type of the value contained in the Predicate.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.23.0
- assertThat
  
  default IntPredicateAssert assertThat(IntPredicate actual)
  
  Create assertion for IntPredicate.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default LongPredicateAssert assertThat(LongPredicate actual)
  
  Create assertion for LongPredicate.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default DoublePredicateAssert assertThat(DoublePredicate actual)
  
  Create assertion for DoublePredicate.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractUrlAssert<?> assertThat(URL actual)
  
  Creates a new instance of UrlAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default AbstractUriAssert<?> assertThat(URI actual)
  
  Creates a new instance of UriAssert.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
- assertThat
  
  default <ELEMENT> SpliteratorAssert<ELEMENT> assertThat(Spliterator<ELEMENT> actual)
  
  Creates a new instance of SpliteratorAssert.
  
  Type Parameters:
  
  ELEMENT - the type of the elements.
  
  Parameters:
  
  actual - the actual value.
  
  Returns:
  
  the created assertion object.
  
  Since:
  
  3.14.0
- assertThat
  
  default <T> T assertThat(AssertProvider<T> component)
  
  Delegates the creation of the Assert to the AssertProvider.assertThat() of the given component.
  Read the comments on AssertProvider for an example of its usage.
  
  Type Parameters:
  
  T - the AssertProvider wrapped type.
  
  Parameters:
  
  component - the component that creates its own assert
  
  Returns:
  
  the associated Assert of the given component
- filter
  
  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).
  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);
  Type Parameters:
  
  E - the array elements type.
  
  Parameters:
  
  array - the array to filter.
  
  Returns:
  
  the created Filters.
- filter
  
  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).
  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);
  Type Parameters:
  
  E - the Iterable elements type.
  
  Parameters:
  
  iterableToFilter - the Iterable to filter.
  
  Returns:
  
  the created Filters.
- in
  
  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.
  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);
  Parameters:
  
  values - values to match (one match is sufficient)
  
  Returns:
  
  the created "in" filter
  
  Since:
  
  3.9.0
- notIn
  
  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.
  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);
  Parameters:
  
  valuesNotToMatch - values not to match (none of the values must match)
  
  Returns:
  
  the created "not in" filter
  
  Since:
  
  3.9.0
- not
  
  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.
  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);
  Parameters:
  
  valueNotToMatch - the value not to match
  
  Returns:
  
  the created "not" filter
  
  Since:
  
  3.9.0
- contentOf
  
  default String contentOf(URL url, Charset charset)
  
  Loads the text content of a URL, so that it can be passed to assertThat(String).
  Note that this will load the entire contents in memory.
  
  Parameters:
  
  url - the URL.
  
  charset - the character set to use.
  
  Returns:
  
  the content of the URL.
  
  Throws:
  
  NullPointerException - if the given charset is null.
  
  UncheckedIOException - if an I/O exception occurs.
  
  Since:
  
  3.9.0
- contentOf
  
  default String contentOf(URL url, String charsetName)
  
  Loads the text content of a URL, so that it can be passed to assertThat(String).
  Note that this will load the entire contents in memory.
  
  Parameters:
  
  url - the URL.
  
  charsetName - the name of the character set to use.
  
  Returns:
  
  the content of the URL.
  
  Throws:
  
  IllegalArgumentException - if the given character set is not supported on this platform.
  
  UncheckedIOException - if an I/O exception occurs.
  
  Since:
  
  3.9.0
- contentOf
  
  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).
  Note that this will load the entire file in memory; for larger files.
  
  Parameters:
  
  url - the URL.
  
  Returns:
  
  the content of the file.
  
  Throws:
  
  UncheckedIOException - if an I/O exception occurs.
  
  Since:
  
  3.9.0
- linesOf
  
  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. The line endings are either \n, \r or \r\n.
  
  Parameters:
  
  url - the URL.
  
  Returns:
  
  the content of the file.
  
  Throws:
  
  NullPointerException - if the given charset is null.
  
  UncheckedIOException - if an I/O exception occurs.
  
  Since:
  
  3.9.0
- linesOf
  
  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. The line endings are either \n, \r or \r\n.
  
  Parameters:
  
  url - the URL.
  
  charset - the character set to use.
  
  Returns:
  
  the content of the file.
  
  Throws:
  
  NullPointerException - if the given charset is null.
  
  UncheckedIOException - if an I/O exception occurs.
  
  Since:
  
  3.9.0
- linesOf
  
  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. The line endings are either \n, \r or \r\n.
  
  Parameters:
  
  url - the URL.
  
  charsetName - the name of the character set to use.
  
  Returns:
  
  the content of the file.
  
  Throws:
  
  NullPointerException - if the given charset is null.
  
  UncheckedIOException - if an I/O exception occurs.
  
  Since:
  
  3.9.0
- useRepresentation
  
  default void useRepresentation(Representation customRepresentation)
  Register a 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$>
  Parameters:
  
  customRepresentation - the Representation to use
  
  Since:
  
  3.9.0
- registerFormatterForType
  
  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.
  Registering a formatter makes it available for all AssertJ Representation:
  
  StandardRepresentation
  
  UnicodeRepresentation
  
  HexadecimalRepresentation
  
  BinaryRepresentation
  
  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);
  Type Parameters:
  
  T - the type of format.
  
  Parameters:
  
  type - the class of the type to format
  
  formatter - the formatter Function
  
  Since:
  
  3.9.0
- useDefaultRepresentation
  
  default void useDefaultRepresentation()
  
  Fallback to use StandardRepresentation to revert the effect of calling useRepresentation(Representation).
  
  Since:
  
  3.9.0

Interface WithAssertions

Field Summary

Fields inherited from interface org.assertj.core.api.InstanceOfAssertFactories

Method Summary

Method Details

offset

offset

entry

fail

fail

fail

fail

fail

not

allOf

allOf

allOf

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThatComparable

assertThat

assertThatIterable

assertThat

assertThat

assertThatIterator

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThatPath

assertThat

assertThat