Uses of Annotation Type
org.assertj.core.util.CheckReturnValue

Packages that use CheckReturnValue

Package	Description
org.assertj.core.api

Uses of CheckReturnValue in org.assertj.core.api

Classes in org.assertj.core.api with annotations of type CheckReturnValue

Modifier and Type	Class	Description
class	Assertions	Entry point for assertion methods for different types.

Methods in org.assertj.core.api with annotations of type CheckReturnValue

Modifier and Type	Method	Description
SELF	AbstractAssert.as(String description, Object... args)	Sets the description of the assertion that is going to be called after.
SELF	AbstractAssert.as(Description description)	Sets the description of the assertion that is going to be called after.
SELF	AbstractIterableAssert.as(String description, Object... args)
SELF	AbstractIterableAssert.as(Description description)
SELF	AbstractListAssert.as(String description, Object... args)
SELF	AbstractListAssert.as(Description description)
SELF	AbstractMapAssert.as(String description, Object... args)
SELF	AbstractMapAssert.as(Description description)
SELF	AbstractObjectAssert.as(String description, Object... args)
SELF	AbstractObjectAssert.as(Description description)
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.as(String description, Object... args)
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.as(Description description)
AbstractListAssert<?,List<?>,Object,ObjectAssert<Object>>	AbstractAssert.asList()	Verifies that the actual value is an instance of List, and returns a list assertion, to allow chaining of list-specific assertions from this call.
PathAssert	AbstractStandardSoftAssertions.assertThat(Path actual)	Creates a new, proxied instance of a PathAssert
InstantAssert	AbstractStandardSoftAssertions.assertThat(Instant actual)	Creates a new instance of InstantAssert.
LocalDateAssert	AbstractStandardSoftAssertions.assertThat(LocalDate actual)	Creates a new instance of LocalDateAssert.
LocalDateTimeAssert	AbstractStandardSoftAssertions.assertThat(LocalDateTime actual)	Creates a new instance of LocalDateTimeAssert.
LocalTimeAssert	AbstractStandardSoftAssertions.assertThat(LocalTime actual)	Creates a new instance of LocalTimeAssert.
OffsetDateTimeAssert	AbstractStandardSoftAssertions.assertThat(OffsetDateTime actual)	Creates a new instance of OffsetDateTimeAssert.
OffsetTimeAssert	AbstractStandardSoftAssertions.assertThat(OffsetTime actual)	Creates a new instance of OffsetTimeAssert.
ZonedDateTimeAssert	AbstractStandardSoftAssertions.assertThat(ZonedDateTime actual)	Creates a new instance of ZonedDateTimeAssert.
<RESULT> CompletableFutureAssert<RESULT>	AbstractStandardSoftAssertions.assertThat(CompletableFuture<RESULT> actual)	Create assertion for CompletableFuture.
DoublePredicateAssert	AbstractStandardSoftAssertions.assertThat(DoublePredicate actual)	Create assertion for DoublePredicate.
IntPredicateAssert	AbstractStandardSoftAssertions.assertThat(IntPredicate actual)	Create assertion for IntPredicate.
LongPredicateAssert	AbstractStandardSoftAssertions.assertThat(LongPredicate actual)	Create assertion for DoublePredicate.
<T> SoftAssertionPredicateAssert<T>	AbstractStandardSoftAssertions.assertThat(Predicate<T> actual)	Create assertion for Predicate.
<VALUE> OptionalAssert<VALUE>	AbstractStandardSoftAssertions.assertThat(Optional<VALUE> actual)	Create assertion for Optional.
OptionalDoubleAssert	AbstractStandardSoftAssertions.assertThat(OptionalDouble actual)	Create assertion for OptionalDouble.
OptionalIntAssert	AbstractStandardSoftAssertions.assertThat(OptionalInt actual)	Create assertion for OptionalInt.
OptionalLongAssert	AbstractStandardSoftAssertions.assertThat(OptionalLong actual)	Create assertion for OptionalLong.
<ELEMENT, STREAM extends BaseStream<ELEMENT, STREAM>> ListAssert<ELEMENT>	AbstractStandardSoftAssertions.assertThat(BaseStream<? extends ELEMENT,STREAM> actual)	Creates a new instance of ListAssert from the given BaseStream.
static AbstractBooleanAssert<?>	Assertions.assertThat(boolean actual)	Creates a new instance of BooleanAssert.
static AbstractBooleanArrayAssert<?>	Assertions.assertThat(boolean[] actual)	Creates a new instance of BooleanArrayAssert.
static AbstractByteAssert<?>	Assertions.assertThat(byte actual)	Creates a new instance of ByteAssert.
static AbstractByteArrayAssert<?>	Assertions.assertThat(byte[] actual)	Creates a new instance of ByteArrayAssert.
static AbstractCharacterAssert<?>	Assertions.assertThat(char actual)	Creates a new instance of CharacterAssert.
static AbstractCharArrayAssert<?>	Assertions.assertThat(char[] actual)	Creates a new instance of CharArrayAssert.
static AbstractDoubleAssert<?>	Assertions.assertThat(double actual)	Creates a new instance of DoubleAssert.
static AbstractDoubleArrayAssert<?>	Assertions.assertThat(double[] actual)	Creates a new instance of DoubleArrayAssert.
static AbstractFloatAssert<?>	Assertions.assertThat(float actual)	Creates a new instance of FloatAssert.
static AbstractFloatArrayAssert<?>	Assertions.assertThat(float[] actual)	Creates a new instance of FloatArrayAssert.
static AbstractIntegerAssert<?>	Assertions.assertThat(int actual)	Creates a new instance of IntegerAssert.
static AbstractIntArrayAssert<?>	Assertions.assertThat(int[] actual)	Creates a new instance of IntArrayAssert.
static AbstractLongAssert<?>	Assertions.assertThat(long actual)	Creates a new instance of LongAssert.
static AbstractLongArrayAssert<?>	Assertions.assertThat(long[] actual)	Creates a new instance of LongArrayAssert.
static AbstractShortAssert<?>	Assertions.assertThat(short actual)	Creates a new instance of ShortAssert.
static AbstractShortArrayAssert<?>	Assertions.assertThat(short[] actual)	Creates a new instance of ShortArrayAssert.
static AbstractFileAssert<?>	Assertions.assertThat(File actual)	Creates a new instance of FileAssert.
static AbstractInputStreamAssert<?,? extends InputStream>	Assertions.assertThat(InputStream actual)	Creates a new instance of InputStreamAssert.
static AbstractBooleanAssert<?>	Assertions.assertThat(Boolean actual)	Creates a new instance of BooleanAssert.
static AbstractByteAssert<?>	Assertions.assertThat(Byte actual)	Creates a new instance of ByteAssert.
static AbstractCharacterAssert<?>	Assertions.assertThat(Character actual)	Creates a new instance of CharacterAssert.
static AbstractCharSequenceAssert<?,? extends CharSequence>	Assertions.assertThat(CharSequence actual)	Creates a new instance of CharSequenceAssert.
static AbstractClassAssert<?>	Assertions.assertThat(Class<?> actual)	Creates a new instance of ClassAssert
static AbstractDoubleAssert<?>	Assertions.assertThat(Double actual)	Creates a new instance of DoubleAssert.
static AbstractFloatAssert<?>	Assertions.assertThat(Float actual)	Creates a new instance of FloatAssert.
static AbstractIntegerAssert<?>	Assertions.assertThat(Integer actual)	Creates a new instance of IntegerAssert.
static <ELEMENT> IterableAssert<ELEMENT>	Assertions.assertThat(Iterable<? extends ELEMENT> actual)	Creates a new instance of IterableAssert.
static AbstractLongAssert<?>	Assertions.assertThat(Long actual)	Creates a new instance of LongAssert.
static AbstractShortAssert<?>	Assertions.assertThat(Short actual)	Creates a new instance of ShortAssert.
static AbstractCharSequenceAssert<?,String>	Assertions.assertThat(String actual)	Creates a new instance of StringAssert.
static AbstractThrowableAssert<?,? extends Throwable>	Assertions.assertThat(Throwable actual)	Creates a new instance of ThrowableAssert.
static AbstractBigDecimalAssert<?>	Assertions.assertThat(BigDecimal actual)	Creates a new instance of BigDecimalAssert.
static AbstractBigIntegerAssert<?>	Assertions.assertThat(BigInteger actual)	Creates a new instance of BigIntegerAssert.
static AbstractUriAssert<?>	Assertions.assertThat(URI actual)	Creates a new instance of UriAssert.
static AbstractUrlAssert<?>	Assertions.assertThat(URL actual)	Creates a new instance of UrlAssert.
static AbstractPathAssert<?>	Assertions.assertThat(Path actual)	Creates a new instance of PathAssert
static AbstractInstantAssert<?>	Assertions.assertThat(Instant actual)	Creates a new instance of InstantAssert.
static AbstractLocalDateAssert<?>	Assertions.assertThat(LocalDate actual)	Creates a new instance of LocalDateAssert.
static AbstractLocalDateTimeAssert<?>	Assertions.assertThat(LocalDateTime actual)	Creates a new instance of LocalDateTimeAssert.
static AbstractLocalTimeAssert<?>	Assertions.assertThat(LocalTime actual)	Creates a new instance of LocalTimeAssert.
static AbstractOffsetDateTimeAssert<?>	Assertions.assertThat(OffsetDateTime actual)	Creates a new instance of OffsetDateTime.
static AbstractOffsetTimeAssert<?>	Assertions.assertThat(OffsetTime actual)	Create assertion for OffsetTime.
static AbstractZonedDateTimeAssert<?>	Assertions.assertThat(ZonedDateTime actual)	Creates a new instance of ZonedDateTimeAssert.
static AtomicBooleanAssert	Assertions.assertThat(AtomicBoolean actual)	Create assertion for AtomicBoolean.
static AtomicIntegerAssert	Assertions.assertThat(AtomicInteger actual)	Create assertion for AtomicInteger.
static AtomicIntegerArrayAssert	Assertions.assertThat(AtomicIntegerArray actual)	Create int[] assertion for AtomicIntegerArray.
static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT>	Assertions.assertThat(AtomicIntegerFieldUpdater<OBJECT> actual)	Create assertion for AtomicIntegerFieldUpdater.
static AtomicLongAssert	Assertions.assertThat(AtomicLong actual)	Create assertion for AtomicLong.
static AtomicLongArrayAssert	Assertions.assertThat(AtomicLongArray actual)	Create assertion for AtomicLongArray.
static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT>	Assertions.assertThat(AtomicLongFieldUpdater<OBJECT> actual)	Create assertion for AtomicLongFieldUpdater.
static <VALUE> AtomicMarkableReferenceAssert<VALUE>	Assertions.assertThat(AtomicMarkableReference<VALUE> actual)	Create assertion for AtomicMarkableReference.
static <VALUE> AtomicReferenceAssert<VALUE>	Assertions.assertThat(AtomicReference<VALUE> actual)	Create assertion for AtomicReference.
static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	Assertions.assertThat(AtomicReferenceArray<ELEMENT> actual)	Create assertion for AtomicReferenceArray.
static <FIELD, OBJECT> AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT>	Assertions.assertThat(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)	Create assertion for AtomicReferenceFieldUpdater.
static <VALUE> AtomicStampedReferenceAssert<VALUE>	Assertions.assertThat(AtomicStampedReference<VALUE> actual)	Create assertion for AtomicStampedReference.
static <RESULT> CompletableFutureAssert<RESULT>	Assertions.assertThat(CompletableFuture<RESULT> actual)	Create assertion for CompletableFuture.
static <RESULT> AbstractFutureAssert<?,? extends Future<? extends RESULT>,RESULT>	Assertions.assertThat(Future<RESULT> actual)	Create assertion for Future.
static AbstractDateAssert<?>	Assertions.assertThat(Date actual)	Creates a new instance of DateAssert.
static DoublePredicateAssert	Assertions.assertThat(DoublePredicate actual)	Create assertion for DoublePredicate.
static IntPredicateAssert	Assertions.assertThat(IntPredicate actual)	Create assertion for IntPredicate.
static LongPredicateAssert	Assertions.assertThat(LongPredicate actual)	Create assertion for LongPredicate.
static <T> PredicateAssert<T>	Assertions.assertThat(Predicate<T> actual)	Create assertion for Predicate.
static <ELEMENT> IterableAssert<ELEMENT>	Assertions.assertThat(Iterator<? extends ELEMENT> actual)	Creates a new instance of IterableAssert.
static <ELEMENT> ListAssert<ELEMENT>	Assertions.assertThat(List<? extends ELEMENT> actual)	Creates a new instance of ListAssert.
static <K, V> MapAssert<K,V>	Assertions.assertThat(Map<K,V> actual)	Creates a new instance of MapAssert.
static <VALUE> OptionalAssert<VALUE>	Assertions.assertThat(Optional<VALUE> actual)	Create assertion for Optional.
static OptionalDoubleAssert	Assertions.assertThat(OptionalDouble actual)	Create assertion for OptionalDouble.
static OptionalIntAssert	Assertions.assertThat(OptionalInt actual)	Create assertion for OptionalInt.
static OptionalLongAssert	Assertions.assertThat(OptionalLong actual)	Create assertion for OptionalInt.
static <ELEMENT, STREAM extends BaseStream<ELEMENT, STREAM>> AbstractListAssert<?,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>	Assertions.assertThat(BaseStream<? extends ELEMENT,STREAM> actual)	Creates a new instance of ListAssert from the given BaseStream.
static <T> AbstractObjectAssert<?,T>	Assertions.assertThat(T actual)	Creates a new instance of ObjectAssert.
static <T extends Comparable<? super T>> AbstractComparableAssert<?,T>	Assertions.assertThat(T actual)	Creates a new instance of GenericComparableAssert with standard comparison semantics.
static <T extends AssertDelegateTarget> T	Assertions.assertThat(T assertion)	Returns the given assertion.
static <T> AbstractObjectArrayAssert<?,T>	Assertions.assertThat(T[] actual)	Creates a new instance of ObjectArrayAssert.
static AbstractBooleanAssert<?>	AssertionsForClassTypes.assertThat(boolean actual)	Creates a new instance of BooleanAssert.
static AbstractBooleanArrayAssert<?>	AssertionsForClassTypes.assertThat(boolean[] actual)	Creates a new instance of BooleanArrayAssert.
static AbstractByteAssert<?>	AssertionsForClassTypes.assertThat(byte actual)	Creates a new instance of ByteAssert.
static AbstractByteArrayAssert<?>	AssertionsForClassTypes.assertThat(byte[] actual)	Creates a new instance of ByteArrayAssert.
static AbstractCharacterAssert<?>	AssertionsForClassTypes.assertThat(char actual)	Creates a new instance of CharacterAssert.
static AbstractCharArrayAssert<?>	AssertionsForClassTypes.assertThat(char[] actual)	Creates a new instance of CharArrayAssert.
static AbstractDoubleAssert<?>	AssertionsForClassTypes.assertThat(double actual)	Creates a new instance of DoubleAssert.
static AbstractDoubleArrayAssert<?>	AssertionsForClassTypes.assertThat(double[] actual)	Creates a new instance of DoubleArrayAssert.
static AbstractFloatAssert<?>	AssertionsForClassTypes.assertThat(float actual)	Creates a new instance of FloatAssert.
static AbstractFloatArrayAssert<?>	AssertionsForClassTypes.assertThat(float[] actual)	Creates a new instance of FloatArrayAssert.
static AbstractIntegerAssert<?>	AssertionsForClassTypes.assertThat(int actual)	Creates a new instance of IntegerAssert.
static AbstractIntArrayAssert<?>	AssertionsForClassTypes.assertThat(int[] actual)	Creates a new instance of IntArrayAssert.
static AbstractLongAssert<?>	AssertionsForClassTypes.assertThat(long actual)	Creates a new instance of LongAssert.
static AbstractLongArrayAssert<?>	AssertionsForClassTypes.assertThat(long[] actual)	Creates a new instance of LongArrayAssert.
static AbstractShortAssert<?>	AssertionsForClassTypes.assertThat(short actual)	Creates a new instance of ShortAssert.
static AbstractShortArrayAssert<?>	AssertionsForClassTypes.assertThat(short[] actual)	Creates a new instance of ShortArrayAssert.
static AbstractFileAssert<?>	AssertionsForClassTypes.assertThat(File actual)	Creates a new instance of FileAssert.
static AbstractInputStreamAssert<?,? extends InputStream>	AssertionsForClassTypes.assertThat(InputStream actual)	Creates a new instance of InputStreamAssert.
static AbstractBooleanAssert<?>	AssertionsForClassTypes.assertThat(Boolean actual)	Creates a new instance of BooleanAssert.
static AbstractByteAssert<?>	AssertionsForClassTypes.assertThat(Byte actual)	Creates a new instance of ByteAssert.
static AbstractCharacterAssert<?>	AssertionsForClassTypes.assertThat(Character actual)	Creates a new instance of CharacterAssert.
static AbstractClassAssert<?>	AssertionsForClassTypes.assertThat(Class<?> actual)	Creates a new instance of ClassAssert
static AbstractDoubleAssert<?>	AssertionsForClassTypes.assertThat(Double actual)	Creates a new instance of DoubleAssert.
static AbstractFloatAssert<?>	AssertionsForClassTypes.assertThat(Float actual)	Creates a new instance of FloatAssert.
static AbstractIntegerAssert<?>	AssertionsForClassTypes.assertThat(Integer actual)	Creates a new instance of IntegerAssert.
static AbstractLongAssert<?>	AssertionsForClassTypes.assertThat(Long actual)	Creates a new instance of LongAssert.
static AbstractShortAssert<?>	AssertionsForClassTypes.assertThat(Short actual)	Creates a new instance of ShortAssert.
static AbstractCharSequenceAssert<?,String>	AssertionsForClassTypes.assertThat(String actual)	Creates a new instance of StringAssert.
static AbstractThrowableAssert<?,? extends Throwable>	AssertionsForClassTypes.assertThat(Throwable actual)	Creates a new instance of ThrowableAssert.
static AbstractBigDecimalAssert<?>	AssertionsForClassTypes.assertThat(BigDecimal actual)	Creates a new instance of BigDecimalAssert.
static AbstractUriAssert<?>	AssertionsForClassTypes.assertThat(URI actual)	Creates a new instance of UriAssert.
static AbstractUrlAssert<?>	AssertionsForClassTypes.assertThat(URL actual)	Creates a new instance of UrlAssert.
static AbstractInstantAssert<?>	AssertionsForClassTypes.assertThat(Instant instant)	Creates a new instance of InstantAssert.
static AbstractLocalDateAssert<?>	AssertionsForClassTypes.assertThat(LocalDate localDate)	Creates a new instance of LocalDateAssert.
static AbstractLocalDateTimeAssert<?>	AssertionsForClassTypes.assertThat(LocalDateTime actual)	Creates a new instance of LocalDateTimeAssert.
static AbstractLocalTimeAssert<?>	AssertionsForClassTypes.assertThat(LocalTime actual)	Creates a new instance of LocalTimeAssert.
static AbstractOffsetDateTimeAssert<?>	AssertionsForClassTypes.assertThat(OffsetDateTime actual)	Creates a new instance of OffsetDateTime.
static AbstractOffsetTimeAssert<?>	AssertionsForClassTypes.assertThat(OffsetTime actual)	Create assertion for OffsetTime.
static AbstractZonedDateTimeAssert<?>	AssertionsForClassTypes.assertThat(ZonedDateTime actual)	Creates a new instance of ZonedDateTimeAssert.
static <RESULT> CompletableFutureAssert<RESULT>	AssertionsForClassTypes.assertThat(CompletableFuture<RESULT> actual)	Create assertion for CompletableFuture.
static AbstractDateAssert<?>	AssertionsForClassTypes.assertThat(Date actual)	Creates a new instance of DateAssert.
static <VALUE> OptionalAssert<VALUE>	AssertionsForClassTypes.assertThat(Optional<VALUE> actual)	Create assertion for Optional.
static OptionalDoubleAssert	AssertionsForClassTypes.assertThat(OptionalDouble actual)	Create assertion for OptionalDouble.
static OptionalIntAssert	AssertionsForClassTypes.assertThat(OptionalInt actual)	Create assertion for OptionalInt.
static OptionalLongAssert	AssertionsForClassTypes.assertThat(OptionalLong actual)	Create assertion for OptionalInt.
static <T> AbstractObjectAssert<?,T>	AssertionsForClassTypes.assertThat(T actual)	Creates a new instance of ObjectAssert.
static <T> AbstractObjectArrayAssert<?,T>	AssertionsForClassTypes.assertThat(T[] actual)	Creates a new instance of ObjectArrayAssert.
static AbstractCharSequenceAssert<?,? extends CharSequence>	AssertionsForInterfaceTypes.assertThat(CharSequence actual)	Creates a new instance of CharSequenceAssert.
static <ELEMENT> IterableAssert<ELEMENT>	AssertionsForInterfaceTypes.assertThat(Iterable<? extends ELEMENT> actual)	Creates a new instance of IterableAssert.
static AbstractPathAssert<?>	AssertionsForInterfaceTypes.assertThat(Path actual)	Creates a new instance of PathAssert
static DoublePredicateAssert	AssertionsForInterfaceTypes.assertThat(DoublePredicate actual)	Create assertion for DoublePredicate.
static IntPredicateAssert	AssertionsForInterfaceTypes.assertThat(IntPredicate actual)	Create assertion for IntPredicate.
static LongPredicateAssert	AssertionsForInterfaceTypes.assertThat(LongPredicate actual)	Create assertion for LongPredicate.
static <T> PredicateAssert<T>	AssertionsForInterfaceTypes.assertThat(Predicate<T> actual)	Create assertion for Predicate.
static <ELEMENT> IterableAssert<ELEMENT>	AssertionsForInterfaceTypes.assertThat(Iterator<? extends ELEMENT> actual)	Creates a new instance of IterableAssert.
static <ELEMENT> ListAssert<ELEMENT>	AssertionsForInterfaceTypes.assertThat(List<? extends ELEMENT> actual)	Creates a new instance of ListAssert.
static <K, V> MapAssert<K,V>	AssertionsForInterfaceTypes.assertThat(Map<K,V> actual)	Creates a new instance of MapAssert.
static <ELEMENT, STREAM extends BaseStream<ELEMENT, STREAM>> ListAssert<ELEMENT>	AssertionsForInterfaceTypes.assertThat(BaseStream<? extends ELEMENT,STREAM> actual)	Creates a new instance of ListAssert from the given BaseStream.
static <T extends Comparable<? super T>> AbstractComparableAssert<?,T>	AssertionsForInterfaceTypes.assertThat(T actual)	Creates a new instance of GenericComparableAssert with standard comparison semantics.
static <T extends AssertDelegateTarget> T	AssertionsForInterfaceTypes.assertThat(T assertion)	Returns the given assertion.
BooleanAssert	Java6AbstractStandardSoftAssertions.assertThat(boolean actual)	Creates a new instance of BooleanAssert.
BooleanArrayAssert	Java6AbstractStandardSoftAssertions.assertThat(boolean[] actual)	Creates a new instance of BooleanArrayAssert.
ByteAssert	Java6AbstractStandardSoftAssertions.assertThat(byte actual)	Creates a new instance of ByteAssert.
ByteArrayAssert	Java6AbstractStandardSoftAssertions.assertThat(byte[] actual)	Creates a new instance of ByteArrayAssert.
CharacterAssert	Java6AbstractStandardSoftAssertions.assertThat(char actual)	Creates a new instance of CharacterAssert.
CharArrayAssert	Java6AbstractStandardSoftAssertions.assertThat(char[] actual)	Creates a new instance of CharArrayAssert.
DoubleAssert	Java6AbstractStandardSoftAssertions.assertThat(double actual)	Creates a new instance of DoubleAssert.
DoubleArrayAssert	Java6AbstractStandardSoftAssertions.assertThat(double[] actual)	Creates a new instance of DoubleArrayAssert.
FloatAssert	Java6AbstractStandardSoftAssertions.assertThat(float actual)	Creates a new instance of FloatAssert.
FloatArrayAssert	Java6AbstractStandardSoftAssertions.assertThat(float[] actual)	Creates a new instance of FloatArrayAssert.
IntegerAssert	Java6AbstractStandardSoftAssertions.assertThat(int actual)	Creates a new instance of IntegerAssert.
IntArrayAssert	Java6AbstractStandardSoftAssertions.assertThat(int[] actual)	Creates a new instance of IntArrayAssert.
LongAssert	Java6AbstractStandardSoftAssertions.assertThat(long actual)	Creates a new instance of LongAssert.
LongArrayAssert	Java6AbstractStandardSoftAssertions.assertThat(long[] actual)	Creates a new instance of LongArrayAssert.
ShortAssert	Java6AbstractStandardSoftAssertions.assertThat(short actual)	Creates a new instance of ShortAssert.
ShortArrayAssert	Java6AbstractStandardSoftAssertions.assertThat(short[] actual)	Creates a new instance of ShortArrayAssert.
FileAssert	Java6AbstractStandardSoftAssertions.assertThat(File actual)	Creates a new instance of FileAssert.
InputStreamAssert	Java6AbstractStandardSoftAssertions.assertThat(InputStream actual)	Creates a new instance of InputStreamAssert.
BooleanAssert	Java6AbstractStandardSoftAssertions.assertThat(Boolean actual)	Creates a new instance of BooleanAssert.
ByteAssert	Java6AbstractStandardSoftAssertions.assertThat(Byte actual)	Creates a new instance of ByteAssert.
CharacterAssert	Java6AbstractStandardSoftAssertions.assertThat(Character actual)	Creates a new instance of CharacterAssert.
CharSequenceAssert	Java6AbstractStandardSoftAssertions.assertThat(CharSequence actual)	Creates a new instance of CharSequenceAssert.
SoftAssertionClassAssert	Java6AbstractStandardSoftAssertions.assertThat(Class<?> actual)	Creates a new instance of ClassAssert
DoubleAssert	Java6AbstractStandardSoftAssertions.assertThat(Double actual)	Creates a new instance of DoubleAssert.
FloatAssert	Java6AbstractStandardSoftAssertions.assertThat(Float actual)	Creates a new instance of FloatAssert.
IntegerAssert	Java6AbstractStandardSoftAssertions.assertThat(Integer actual)	Creates a new instance of IntegerAssert.
<T> SoftAssertionIterableAssert<T>	Java6AbstractStandardSoftAssertions.assertThat(Iterable<? extends T> actual)	Creates a new instance of IterableAssert.
LongAssert	Java6AbstractStandardSoftAssertions.assertThat(Long actual)	Creates a new instance of LongAssert.
ShortAssert	Java6AbstractStandardSoftAssertions.assertThat(Short actual)	Creates a new instance of ShortAssert.
StringAssert	Java6AbstractStandardSoftAssertions.assertThat(String actual)	Creates a new instance of StringAssert.
ThrowableAssert	Java6AbstractStandardSoftAssertions.assertThat(Throwable actual)	Creates a new instance of ThrowableAssert.
BigDecimalAssert	Java6AbstractStandardSoftAssertions.assertThat(BigDecimal actual)	Creates a new instance of BigDecimalAssert.
BigIntegerAssert	Java6AbstractStandardSoftAssertions.assertThat(BigInteger actual)	Creates a new instance of BigInteger.
UriAssert	Java6AbstractStandardSoftAssertions.assertThat(URI actual)	Creates a new instance of UriAssert.
AbstractUrlAssert<?>	Java6AbstractStandardSoftAssertions.assertThat(URL actual)	Creates a new instance of UrlAssert.
AtomicBooleanAssert	Java6AbstractStandardSoftAssertions.assertThat(AtomicBoolean actual)	Create assertion for AtomicBoolean.
AtomicIntegerAssert	Java6AbstractStandardSoftAssertions.assertThat(AtomicInteger actual)	Create assertion for AtomicInteger.
AtomicIntegerArrayAssert	Java6AbstractStandardSoftAssertions.assertThat(AtomicIntegerArray actual)	Create assertion for AtomicIntegerArray.
<OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT>	Java6AbstractStandardSoftAssertions.assertThat(AtomicIntegerFieldUpdater<OBJECT> actual)	Create assertion for AtomicIntegerFieldUpdater.
AtomicLongAssert	Java6AbstractStandardSoftAssertions.assertThat(AtomicLong actual)	Create assertion for AtomicLong.
AtomicLongArrayAssert	Java6AbstractStandardSoftAssertions.assertThat(AtomicLongArray actual)	Create assertion for AtomicLongArray.
<OBJECT> AtomicLongFieldUpdaterAssert<OBJECT>	Java6AbstractStandardSoftAssertions.assertThat(AtomicLongFieldUpdater<OBJECT> actual)	Create assertion for AtomicLongFieldUpdater.
<VALUE> AtomicMarkableReferenceAssert<VALUE>	Java6AbstractStandardSoftAssertions.assertThat(AtomicMarkableReference<VALUE> actual)	Create assertion for AtomicMarkableReference.
<VALUE> AtomicReferenceAssert<VALUE>	Java6AbstractStandardSoftAssertions.assertThat(AtomicReference<VALUE> actual)	Create assertion for AtomicReference.
<ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	Java6AbstractStandardSoftAssertions.assertThat(AtomicReferenceArray<ELEMENT> actual)	Create assertion for AtomicReferenceArray.
<FIELD, OBJECT> AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT>	Java6AbstractStandardSoftAssertions.assertThat(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)	Create assertion for AtomicReferenceFieldUpdater.
<VALUE> AtomicStampedReferenceAssert<VALUE>	Java6AbstractStandardSoftAssertions.assertThat(AtomicStampedReference<VALUE> actual)	Create assertion for AtomicStampedReference.
<RESULT> FutureAssert<RESULT>	Java6AbstractStandardSoftAssertions.assertThat(Future<? extends RESULT> actual)	Creates a new instance of FutureAssert.
DateAssert	Java6AbstractStandardSoftAssertions.assertThat(Date actual)	Creates a new instance of DateAssert.
<T> SoftAssertionIterableAssert<T>	Java6AbstractStandardSoftAssertions.assertThat(Iterator<T> actual)	Creates a new instance of IterableAssert.
<T> SoftAssertionListAssert<T>	Java6AbstractStandardSoftAssertions.assertThat(List<? extends T> actual)	Creates a new instance of ListAssert.
<K, V> SoftAssertionMapAssert<K,V>	Java6AbstractStandardSoftAssertions.assertThat(Map<K,V> actual)	Creates a new instance of MapAssert.
<T extends Comparable<? super T>> AbstractComparableAssert<?,T>	Java6AbstractStandardSoftAssertions.assertThat(T actual)	Creates a new instance of GenericComparableAssert with standard comparison semantics.
<T> ObjectAssert<T>	Java6AbstractStandardSoftAssertions.assertThat(T actual)	Creates a new instance of ObjectAssert.
<T> ObjectArrayAssert<T>	Java6AbstractStandardSoftAssertions.assertThat(T[] actual)	Creates a new instance of ObjectArrayAssert.
static AbstractBooleanAssert<?>	Java6Assertions.assertThat(boolean actual)	Creates a new instance of BooleanAssert.
static AbstractBooleanArrayAssert<?>	Java6Assertions.assertThat(boolean[] actual)	Creates a new instance of BooleanArrayAssert.
static AbstractByteAssert<?>	Java6Assertions.assertThat(byte actual)	Creates a new instance of ByteAssert.
static AbstractByteArrayAssert<?>	Java6Assertions.assertThat(byte[] actual)	Creates a new instance of ByteArrayAssert.
static AbstractCharacterAssert<?>	Java6Assertions.assertThat(char actual)	Creates a new instance of CharacterAssert.
static AbstractCharArrayAssert<?>	Java6Assertions.assertThat(char[] actual)	Creates a new instance of CharArrayAssert.
static AbstractDoubleAssert<?>	Java6Assertions.assertThat(double actual)	Creates a new instance of DoubleAssert.
static AbstractDoubleArrayAssert<?>	Java6Assertions.assertThat(double[] actual)	Creates a new instance of DoubleArrayAssert.
static AbstractFloatAssert<?>	Java6Assertions.assertThat(float actual)	Creates a new instance of FloatAssert.
static AbstractFloatArrayAssert<?>	Java6Assertions.assertThat(float[] actual)	Creates a new instance of FloatArrayAssert.
static AbstractIntegerAssert<?>	Java6Assertions.assertThat(int actual)	Creates a new instance of IntegerAssert.
static AbstractIntArrayAssert<?>	Java6Assertions.assertThat(int[] actual)	Creates a new instance of IntArrayAssert.
static AbstractLongAssert<?>	Java6Assertions.assertThat(long actual)	Creates a new instance of LongAssert.
static AbstractLongArrayAssert<?>	Java6Assertions.assertThat(long[] actual)	Creates a new instance of LongArrayAssert.
static AbstractShortAssert<?>	Java6Assertions.assertThat(short actual)	Creates a new instance of ShortAssert.
static AbstractShortArrayAssert<?>	Java6Assertions.assertThat(short[] actual)	Creates a new instance of ShortArrayAssert.
static AbstractFileAssert<?>	Java6Assertions.assertThat(File actual)	Creates a new instance of FileAssert.
static AbstractInputStreamAssert<?,? extends InputStream>	Java6Assertions.assertThat(InputStream actual)	Creates a new instance of InputStreamAssert.
static AbstractBooleanAssert<?>	Java6Assertions.assertThat(Boolean actual)	Creates a new instance of BooleanAssert.
static AbstractByteAssert<?>	Java6Assertions.assertThat(Byte actual)	Creates a new instance of ByteAssert.
static AbstractCharacterAssert<?>	Java6Assertions.assertThat(Character actual)	Creates a new instance of CharacterAssert.
static AbstractCharSequenceAssert<?,? extends CharSequence>	Java6Assertions.assertThat(CharSequence actual)	Creates a new instance of CharSequenceAssert.
static AbstractClassAssert<?>	Java6Assertions.assertThat(Class<?> actual)	Creates a new instance of ClassAssert
static AbstractDoubleAssert<?>	Java6Assertions.assertThat(Double actual)	Creates a new instance of DoubleAssert.
static AbstractFloatAssert<?>	Java6Assertions.assertThat(Float actual)	Creates a new instance of FloatAssert.
static AbstractIntegerAssert<?>	Java6Assertions.assertThat(Integer actual)	Creates a new instance of IntegerAssert.
static <T> AbstractIterableAssert<?,Iterable<? extends T>,T,ObjectAssert<T>>	Java6Assertions.assertThat(Iterable<? extends T> actual)	Creates a new instance of IterableAssert.
static AbstractLongAssert<?>	Java6Assertions.assertThat(Long actual)	Creates a new instance of LongAssert.
static AbstractShortAssert<?>	Java6Assertions.assertThat(Short actual)	Creates a new instance of ShortAssert.
static AbstractCharSequenceAssert<?,String>	Java6Assertions.assertThat(String actual)	Creates a new instance of StringAssert.
static AbstractThrowableAssert<?,? extends Throwable>	Java6Assertions.assertThat(Throwable actual)	Creates a new instance of ThrowableAssert.
static AbstractBigDecimalAssert<?>	Java6Assertions.assertThat(BigDecimal actual)	Creates a new instance of BigDecimalAssert.
static AbstractBigIntegerAssert<?>	Java6Assertions.assertThat(BigInteger actual)	Creates a new instance of BigIntegerAssert.
static AbstractUriAssert<?>	Java6Assertions.assertThat(URI actual)	Creates a new instance of UriAssert.
static AbstractUrlAssert<?>	Java6Assertions.assertThat(URL actual)	Creates a new instance of UrlAssert.
static AtomicBooleanAssert	Java6Assertions.assertThat(AtomicBoolean actual)	Create assertion for AtomicBoolean.
static AtomicIntegerAssert	Java6Assertions.assertThat(AtomicInteger actual)	Create assertion for AtomicInteger.
static AtomicIntegerArrayAssert	Java6Assertions.assertThat(AtomicIntegerArray actual)	Create int[] assertion for AtomicIntegerArray.
static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT>	Java6Assertions.assertThat(AtomicIntegerFieldUpdater<OBJECT> actual)	Create assertion for AtomicIntegerFieldUpdater.
static AtomicLongAssert	Java6Assertions.assertThat(AtomicLong actual)	Create assertion for AtomicLong.
static AtomicLongArrayAssert	Java6Assertions.assertThat(AtomicLongArray actual)	Create assertion for AtomicLongArray.
static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT>	Java6Assertions.assertThat(AtomicLongFieldUpdater<OBJECT> actual)	Create assertion for AtomicLongFieldUpdater.
static <VALUE> AtomicMarkableReferenceAssert<VALUE>	Java6Assertions.assertThat(AtomicMarkableReference<VALUE> actual)	Create assertion for AtomicMarkableReference.
static <VALUE> AtomicReferenceAssert<VALUE>	Java6Assertions.assertThat(AtomicReference<VALUE> actual)	Create assertion for AtomicReference.
static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	Java6Assertions.assertThat(AtomicReferenceArray<ELEMENT> actual)	Create assertion for AtomicReferenceArray.
static <FIELD, OBJECT> AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT>	Java6Assertions.assertThat(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)	Create assertion for AtomicReferenceFieldUpdater.
static <VALUE> AtomicStampedReferenceAssert<VALUE>	Java6Assertions.assertThat(AtomicStampedReference<VALUE> actual)	Create assertion for AtomicStampedReference.
static <RESULT> AbstractFutureAssert<?,? extends Future<? extends RESULT>,RESULT>	Java6Assertions.assertThat(Future<RESULT> actual)	Create assertion for Future.
static AbstractDateAssert<?>	Java6Assertions.assertThat(Date actual)	Creates a new instance of DateAssert.
static <T> AbstractIterableAssert<?,Iterable<? extends T>,T,ObjectAssert<T>>	Java6Assertions.assertThat(Iterator<? extends T> actual)	Creates a new instance of IterableAssert.
static <T> AbstractListAssert<?,List<? extends T>,T,ObjectAssert<T>>	Java6Assertions.assertThat(List<? extends T> actual)	Creates a new instance of ListAssert.
static <K, V> MapAssert<K,V>	Java6Assertions.assertThat(Map<K,V> actual)	Creates a new instance of MapAssert.
static <T extends Comparable<? super T>> AbstractComparableAssert<?,T>	Java6Assertions.assertThat(T actual)	Creates a new instance of GenericComparableAssert with standard comparison semantics.
static <T> AbstractObjectAssert<?,T>	Java6Assertions.assertThat(T actual)	Creates a new instance of ObjectAssert.
static <T extends AssertDelegateTarget> T	Java6Assertions.assertThat(T assertion)	Returns the given assertion.
static <T> AbstractObjectArrayAssert<?,T>	Java6Assertions.assertThat(T[] actual)	Creates a new instance of ObjectArrayAssert.
default AbstractBooleanAssert<?>	WithAssertions.assertThat(boolean actual)	Delegate call to Assertions.assertThat(boolean)
default AbstractBooleanArrayAssert<?>	WithAssertions.assertThat(boolean[] actual)	Delegate call to Assertions.assertThat(boolean)
default AbstractByteAssert<?>	WithAssertions.assertThat(byte actual)	Delegate call to Assertions.assertThat(byte)
default AbstractByteArrayAssert<?>	WithAssertions.assertThat(byte[] actual)	Delegate call to Assertions.assertThat(byte[])
default AbstractCharacterAssert<?>	WithAssertions.assertThat(char actual)	Delegate call to Assertions.assertThat(char)
default AbstractCharArrayAssert<?>	WithAssertions.assertThat(char[] actual)	Delegate call to Assertions.assertThat(char[])
default AbstractDoubleAssert<?>	WithAssertions.assertThat(double actual)	Delegate call to Assertions.assertThat(double)
default AbstractDoubleArrayAssert<?>	WithAssertions.assertThat(double[] actual)	Delegate call to Assertions.assertThat(double[])
default AbstractFloatAssert<?>	WithAssertions.assertThat(float actual)	Delegate call to Assertions.assertThat(float)
default AbstractFloatArrayAssert<?>	WithAssertions.assertThat(float[] actual)	Delegate call to Assertions.assertThat(float[])
default AbstractIntegerAssert<?>	WithAssertions.assertThat(int actual)	Delegate call to Assertions.assertThat(int)
default AbstractIntArrayAssert<?>	WithAssertions.assertThat(int[] actual)	Delegate call to Assertions.assertThat(int[])
default AbstractLongAssert<?>	WithAssertions.assertThat(long actual)	Delegate call to Assertions.assertThat(long)
default AbstractLongArrayAssert<?>	WithAssertions.assertThat(long[] actual)	Delegate call to Assertions.assertThat(long[])
default AbstractShortAssert<?>	WithAssertions.assertThat(short actual)	Delegate call to Assertions.assertThat(short)
default AbstractShortArrayAssert<?>	WithAssertions.assertThat(short[] actual)	Delegate call to Assertions.assertThat(short[])
default <ACTUAL extends Iterable<? extends ELEMENT>, ELEMENT, ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT, ELEMENT>> ClassBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT>	WithAssertions.assertThat(ACTUAL actual, Class<ELEMENT_ASSERT> assertClass)	Delegate call to Assertions.assertThat(Iterable, Class)
default AbstractFileAssert<?>	WithAssertions.assertThat(File actual)	Delegate call to Assertions.assertThat(File)
default AbstractInputStreamAssert<?,? extends InputStream>	WithAssertions.assertThat(InputStream actual)	Delegate call to Assertions.assertThat(InputStream)
default AbstractBooleanAssert<?>	WithAssertions.assertThat(Boolean actual)	Delegate call to Assertions.assertThat(Boolean)
default AbstractByteAssert<?>	WithAssertions.assertThat(Byte actual)	Delegate call to Assertions.assertThat(Byte)
default AbstractCharacterAssert<?>	WithAssertions.assertThat(Character actual)	Delegate call to Assertions.assertThat(Character)
default AbstractCharSequenceAssert<?,? extends CharSequence>	WithAssertions.assertThat(CharSequence actual)	Delegate call to Assertions.assertThat(CharSequence)
default AbstractClassAssert<?>	WithAssertions.assertThat(Class<?> actual)	Delegate call to Assertions.assertThat(Class)
default AbstractDoubleAssert<?>	WithAssertions.assertThat(Double actual)	Delegate call to Assertions.assertThat(Double)
default AbstractFloatAssert<?>	WithAssertions.assertThat(Float actual)	Delegate call to Assertions.assertThat(Float)
default AbstractIntegerAssert<?>	WithAssertions.assertThat(Integer actual)	Delegate call to Assertions.assertThat(Integer)
default <ACTUAL extends Iterable<? extends ELEMENT>, ELEMENT, ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT, ELEMENT>> FactoryBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT>	WithAssertions.assertThat(Iterable<? extends ELEMENT> actual, AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)	Delegate call to Assertions.assertThat(Iterable, AssertFactory)
default <T> IterableAssert<T>	WithAssertions.assertThat(Iterable<? extends T> actual)	Delegate call to Assertions.assertThat(Iterable)
default AbstractLongAssert<?>	WithAssertions.assertThat(Long actual)	Delegate call to Assertions.assertThat(Long)
default AbstractShortAssert<?>	WithAssertions.assertThat(Short actual)	Delegate call to Assertions.assertThat(Short)
default AbstractCharSequenceAssert<?,String>	WithAssertions.assertThat(String actual)	Delegate call to Assertions.assertThat(String)
default AbstractThrowableAssert<?,? extends Throwable>	WithAssertions.assertThat(Throwable actual)	Delegate call to Assertions.assertThat(Throwable)
default AbstractBigDecimalAssert<?>	WithAssertions.assertThat(BigDecimal actual)	Delegate call to Assertions.assertThat(BigDecimal)
default AbstractBigIntegerAssert<?>	WithAssertions.assertThat(BigInteger actual)	Creates a new instance of BigIntegerAssert.
default AbstractPathAssert<?>	WithAssertions.assertThat(Path actual)	Delegate call to Assertions.assertThat(Path)
default <RESULT> AbstractFutureAssert<?,? extends Future<? extends RESULT>,RESULT>	WithAssertions.assertThat(Future<RESULT> actual)	Delegate call to Assertions.assertThat(Future)
default AbstractDateAssert<?>	WithAssertions.assertThat(Date actual)	Delegate call to Assertions.assertThat(Date)
default <T> IterableAssert<T>	WithAssertions.assertThat(Iterator<? extends T> actual)	Delegate call to Assertions.assertThat(Iterator)
default <ELEMENT, ACTUAL extends List<? extends ELEMENT>, ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT, ELEMENT>> ClassBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT>	WithAssertions.assertThat(List<? extends ELEMENT> actual, Class<ELEMENT_ASSERT> assertClass)	Delegate call to Assertions.assertThat(List, Class) )}
default <ACTUAL extends List<? extends ELEMENT>, ELEMENT, ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT, ELEMENT>> FactoryBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT>	WithAssertions.assertThat(List<? extends ELEMENT> actual, AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)	Delegate call to Assertions.assertThat(List, AssertFactory) )}
default <T> ListAssert<? extends T>	WithAssertions.assertThat(List<? extends T> actual)	Delegate call to Assertions.assertThat(List)
default <K, V> MapAssert<K,V>	WithAssertions.assertThat(Map<K,V> actual)	Delegate call to Assertions.assertThat(Map)
default <ELEMENT, STREAM extends BaseStream<ELEMENT, STREAM>> AbstractListAssert<?,? extends List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>	WithAssertions.assertThat(BaseStream<? extends ELEMENT,STREAM> actual)	Delegate call to Assertions.assertThat(List)
default <T extends AssertDelegateTarget> T	WithAssertions.assertThat(T assertion)	Delegate call to Assertions.assertThat(AssertDelegateTarget)
default <T> AbstractObjectAssert<?,T>	WithAssertions.assertThat(T actual)	Delegate call to Assertions.assertThat(Object)
default <T extends Comparable<? super T>> AbstractComparableAssert<?,T>	WithAssertions.assertThat(T actual)	Delegate call to Assertions.assertThat(Comparable)
default <T> AbstractObjectArrayAssert<?,T>	WithAssertions.assertThat(T[] actual)	Delegate call to Assertions.assertThat(Object[])
static AbstractThrowableAssert<?,? extends Throwable>	Assertions.assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)	Allows to capture and then assert on a Throwable more easily when used with Java 8 lambdas.
static AbstractThrowableAssert<?,? extends Throwable>	AssertionsForClassTypes.assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)	Allows to capture and then assert on a Throwable more easily when used with Java 8 lambdas.
AbstractThrowableAssert<?,? extends Throwable>	Java6AbstractStandardSoftAssertions.assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)	Allows to capture and then assert on a Throwable more easily when used with Java 8 lambdas.
static AbstractThrowableAssert<?,? extends Throwable>	Java6Assertions.assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)	Allows to capture and then assert on a Throwable.
default AbstractThrowableAssert<?,? extends Throwable>	WithAssertions.assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)	Allows to capture and then assert on a Throwable more easily when used with Java 8 lambdas.
static <T extends Throwable> ThrowableTypeAssert<T>	Assertions.assertThatExceptionOfType(Class<? extends T> exceptionType)	Entry point to check that an exception of type T is thrown by a given throwingCallable which allows to chain assertions on the thrown exception.
static <T extends Throwable> ThrowableTypeAssert<T>	AssertionsForClassTypes.assertThatExceptionOfType(Class<? extends T> exceptionType)	Entry point to check that an exception of type T is thrown by a given throwingCallable which allows to chain assertions on the thrown exception.
static ThrowableTypeAssert<IllegalArgumentException>	Assertions.assertThatIllegalArgumentException()	Alias for Assertions.assertThatExceptionOfType(Class) for IllegalArgumentException.
static ThrowableTypeAssert<IllegalStateException>	Assertions.assertThatIllegalStateException()	Alias for Assertions.assertThatExceptionOfType(Class) for IllegalStateException.
static ThrowableTypeAssert<IOException>	Assertions.assertThatIOException()	Alias for Assertions.assertThatExceptionOfType(Class) for IOException.
static ThrowableTypeAssert<NullPointerException>	Assertions.assertThatNullPointerException()	Alias for Assertions.assertThatExceptionOfType(Class) for NullPointerException.
static AbstractThrowableAssert<?,? extends Throwable>	Assertions.assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)	Allows to capture and then assert on a Throwable more easily when used with Java 8 lambdas.
static AbstractThrowableAssert<?,? extends Throwable>	AssertionsForClassTypes.assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)	Allows to capture and then assert on a Throwable.
AbstractThrowableAssert<?,? extends Throwable>	Java6AbstractStandardSoftAssertions.assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)	Allows to capture and then assert on a Throwable more easily when used with Java 8 lambdas.
static AbstractThrowableAssert<?,? extends Throwable>	Java6Assertions.assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)	Allows to capture and then assert on a Throwable more easily when used with Java 8 lambdas.
AbstractCharSequenceAssert<?,String>	AbstractAssert.asString()	Verifies that the actual value is an instance of String, and returns a String assertion, to allow chaining of String-specific assertions from this call.
SELF	AbstractAssert.describedAs(String description, Object... args)	Sets the description of the assertion that is going to be called after.
SELF	AbstractAssert.describedAs(Description description)	Sets the description of the assertion that is going to be called after.
SELF	AbstractIterableAssert.describedAs(String description, Object... args)
SELF	AbstractIterableAssert.describedAs(Description description)
SELF	AbstractListAssert.describedAs(String description, Object... args)
SELF	AbstractListAssert.describedAs(Description description)
SELF	AbstractMapAssert.describedAs(String description, Object... args)
SELF	AbstractMapAssert.describedAs(Description description)
ELEMENT_ASSERT	AbstractIterableAssert.element(int index)	Navigate and allow to perform assertions on the chosen element of the Iterable under test.
AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>>	AbstractIterableAssert.extracting(String propertyOrField)	Extract the values of the given field or property from the Iterable's elements under test into a new Iterable, this new Iterable becoming the Iterable under test.
AbstractListAssert<?,List<? extends Tuple>,Tuple,ObjectAssert<Tuple>>	AbstractIterableAssert.extracting(String... propertiesOrFields)	Extract the values of the given fields/properties from the Iterable's elements under test into a new Iterable composed of Tuples (a simple data structure), this new Iterable becoming the Iterable under test.
<P> AbstractListAssert<?,List<? extends P>,P,ObjectAssert<P>>	AbstractIterableAssert.extracting(String propertyOrField, Class<P> extractingType)	Extract the values of given field or property from the Iterable's elements under test into a new Iterable, this new Iterable becoming the Iterable under test.
final ListAssert<Tuple>	AbstractIterableAssert.extracting(Function<ELEMENT,?>... extractors)	Use the given Functions to extract the values from the Iterable's elements into a new Iterable composed of Tuples (a simple data structure containing the extracted values), this new Iterable becoming the object under test.
<V> AbstractListAssert<?,List<? extends V>,V,ObjectAssert<V>>	AbstractIterableAssert.extracting(Extractor<? super ELEMENT,V> extractor)	Extract the values from Iterable's elements under test by applying an extracting function on them.
<V, EXCEPTION extends Exception> AbstractListAssert<?,List<? extends V>,V,ObjectAssert<V>>	AbstractIterableAssert.extracting(ThrowingExtractor<? super ELEMENT,V,EXCEPTION> extractor)	Extract the values from Iterable's elements under test by applying an extracting function (which might throw an exception) on them.
AbstractObjectArrayAssert<?,Object>	AbstractMapAssert.extracting(String... keys)	Extract the values of given keys from the map under test into an array, this new array becoming the object under test.
ObjectArrayAssert<Object>	AbstractObjectArrayAssert.extracting(String fieldOrProperty)	Extract the values of given field or property from the array's elements under test into a new array, this new array becoming the array under test.
ObjectArrayAssert<Tuple>	AbstractObjectArrayAssert.extracting(String... propertiesOrFields)	Extract the values of given fields/properties from the array's elements under test into a new array composed of Tuple (a simple data structure), this new array becoming the array under test.
<P> ObjectArrayAssert<P>	AbstractObjectArrayAssert.extracting(String fieldOrProperty, Class<P> extractingType)	Extract the values of given field or property from the array's elements under test into a new array, this new array becoming the array under test with type.
final ObjectArrayAssert<Tuple>	AbstractObjectArrayAssert.extracting(Function<ELEMENT,?>... extractors)	Use the given Functions to extract the values from the array's elements into a new array composed of Tuples (a simple data structure containing the extracted values), this new array becoming the object under test.
<U> ObjectArrayAssert<U>	AbstractObjectArrayAssert.extracting(Extractor<? super ELEMENT,U> extractor)	Extract the values from the array's elements by applying an extracting function on them.
AbstractObjectArrayAssert<?,Object>	AbstractObjectAssert.extracting(String... propertiesOrFields)	Extract the values of given fields/properties from the object under test into an array, this new array becoming the object under test.
final AbstractObjectArrayAssert<?,Object>	AbstractObjectAssert.extracting(Function<? super ACTUAL,Object>... extractors)	Use the given Functions to extract the values from the object under test into an array, this new array becoming the object under test.
ObjectArrayAssert<Object>	AtomicReferenceArrayAssert.extracting(String fieldOrProperty)	Extract the values of given field or property from the array's elements under test into a new array, this new array becoming the array under test.
ObjectArrayAssert<Tuple>	AtomicReferenceArrayAssert.extracting(String... propertiesOrFields)	Extract the values of given fields/properties from the array's elements under test into a new array composed of Tuple (a simple data structure), this new array becoming the array under test.
<P> ObjectArrayAssert<P>	AtomicReferenceArrayAssert.extracting(String fieldOrProperty, Class<P> extractingType)	Extract the values of given field or property from the array's elements under test into a new array, this new array becoming the array under test with type.
<U> ObjectArrayAssert<U>	AtomicReferenceArrayAssert.extracting(Extractor<? super T,U> extractor)	Extract the values from the array's elements by applying an extracting function on them.
<U, EXCEPTION extends Exception> ObjectArrayAssert<U>	AtomicReferenceArrayAssert.extracting(ThrowingExtractor<? super T,U,EXCEPTION> extractor)	Extract the values from the array's elements by applying an extracting function (which might throw an exception) on them.
AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>>	AbstractIterableAssert.extractingResultOf(String method)	Extract the result of given method invocation on the Iterable's elements under test into a new Iterable, this new Iterable becoming the Iterable under test.
<P> AbstractListAssert<?,List<? extends P>,P,ObjectAssert<P>>	AbstractIterableAssert.extractingResultOf(String method, Class<P> extractedType)	Extract the result of given method invocation on the Iterable's elements under test into a new list of the given class, this new List becoming the object under test.
ObjectArrayAssert<Object>	AbstractObjectArrayAssert.extractingResultOf(String method)	Extract the result of given method invocation from the array's elements under test into a new array, this new array becoming the array under test.
<P> ObjectArrayAssert<P>	AbstractObjectArrayAssert.extractingResultOf(String method, Class<P> extractingType)	Extract the result of given method invocation from the array's elements under test into a new array, this new array becoming the array under test.
ObjectArrayAssert<Object>	AtomicReferenceArrayAssert.extractingResultOf(String method)	Extract the result of given method invocation from the array's elements under test into a new array, this new array becoming the array under test.
<P> ObjectArrayAssert<P>	AtomicReferenceArrayAssert.extractingResultOf(String method, Class<P> extractingType)	Extract the result of given method invocation from the array's elements under test into a new array, this new array becoming the array under test.
AbstractListAssert<?,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>	AbstractIterableAssert.filteredOn(String propertyOrFieldName, Object expectedValue)	Filter the iterable under test keeping only elements having a property or field equal to expectedValue, the property/field is specified by propertyOrFieldName parameter.
AbstractListAssert<?,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>	AbstractIterableAssert.filteredOn(String propertyOrFieldName, FilterOperator<?> filterOperator)	Filter the iterable under test keeping only elements having a property or field matching the filter expressed with the FilterOperator, the property/field is specified by propertyOrFieldName parameter.
AbstractListAssert<?,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>	AbstractIterableAssert.filteredOn(Condition<? super ELEMENT> condition)	Filter the iterable under test keeping only elements matching the given Condition.
SELF	AbstractObjectArrayAssert.filteredOn(String propertyOrFieldName, Object expectedValue)	Filter the array under test keeping only elements having a property or field equal to expectedValue, the property/field is specified by propertyOrFieldName parameter.
SELF	AbstractObjectArrayAssert.filteredOn(String propertyOrFieldName, FilterOperator<?> filterOperator)	Filter the array under test keeping only elements having a property or field matching the filter expressed with the FilterOperator, the property/field is specified by propertyOrFieldName parameter.
SELF	AbstractObjectArrayAssert.filteredOn(Condition<? super ELEMENT> condition)	Filter the array under test keeping only elements matching the given Condition.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.filteredOn(String propertyOrFieldName, Object expectedValue)	Filter the array under test keeping only elements having a property or field equal to expectedValue, the property/field is specified by propertyOrFieldName parameter.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.filteredOn(String propertyOrFieldName, FilterOperator<?> filterOperator)	Filter the array under test keeping only elements having a property or field matching the filter expressed with the FilterOperator, the property/field is specified by propertyOrFieldName parameter.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.filteredOn(Condition<? super T> condition)	Filter the array under test keeping only elements matching the given Condition.
AbstractListAssert<?,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>	AbstractIterableAssert.filteredOnNull(String propertyOrFieldName)	Filter the iterable under test keeping only elements whose property or field specified by propertyOrFieldName is null.
SELF	AbstractObjectArrayAssert.filteredOnNull(String propertyOrFieldName)	Filter the array under test keeping only elements whose property or field specified by propertyOrFieldName is null.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.filteredOnNull(String propertyOrFieldName)	Filter the array under test keeping only elements whose property or field specified by propertyOrFieldName is null.
ELEMENT_ASSERT	AbstractIterableAssert.first()	Navigate and allow to perform assertions on the first element of the Iterable under test.
AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>>	AbstractIterableAssert.flatExtracting(String fieldOrPropertyName)	Extract from Iterable's elements the Iterable/Array values corresponding to the given property/field name and concatenate them into a single list becoming the new object under test.
AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>>	AbstractIterableAssert.flatExtracting(String... fieldOrPropertyNames)	Extract the given property/field values from each Iterable's element and flatten the extracted values in a list that is used as the new object under test.
final ListAssert<Object>	AbstractIterableAssert.flatExtracting(Extractor<? super ELEMENT,?>... extractors)	Extract multiple values from each Iterable's element according to the given Extractors and concatenate/flatten the extracted values in a list that is used as the new object under test.
<V> AbstractListAssert<?,List<? extends V>,V,ObjectAssert<V>>	AbstractIterableAssert.flatExtracting(Extractor<? super ELEMENT,? extends Collection<V>> extractor)	Extract the Iterable values from Iterable's elements under test by applying an Iterable extracting function on them and concatenating the result lists.
final <EXCEPTION extends Exception> ListAssert<Object>	AbstractIterableAssert.flatExtracting(ThrowingExtractor<? super ELEMENT,?,EXCEPTION>... extractors)	Extract multiple values from each Iterable's element according to the given ThrowingExtractors and concatenate/flatten the extracted values in a list that is used as the new object under test.
<V, EXCEPTION extends Exception> AbstractListAssert<?,List<? extends V>,V,ObjectAssert<V>>	AbstractIterableAssert.flatExtracting(ThrowingExtractor<? super ELEMENT,? extends Collection<V>,EXCEPTION> extractor)	Extract the Iterable values from Iterable's elements under test by applying an Iterable extracting function (which might throw an exception) on them and concatenating the result lists.
ObjectArrayAssert<Object>	AbstractObjectArrayAssert.flatExtracting(String propertyName)	Extract from array's elements the Iterable/Array values corresponding to the given property/field name and concatenate them into a single array becoming the new object under test.
<U, C extends Collection<U>> ObjectArrayAssert<U>	AbstractObjectArrayAssert.flatExtracting(Extractor<? super ELEMENT,C> extractor)	Extract the Iterable values from arrays elements under test by applying an Iterable extracting function on them and concatenating the result lists into an array which becomes the new object under test.
<U, C extends Collection<U>, EXCEPTION extends Exception> ObjectArrayAssert<U>	AbstractObjectArrayAssert.flatExtracting(ThrowingExtractor<? super ELEMENT,C,EXCEPTION> extractor)	Extract the Iterable values from arrays elements under test by applying an Iterable extracting function (which might throw an exception) on them and concatenating the result lists into an array which becomes the new object under test.
ObjectArrayAssert<Object>	AtomicReferenceArrayAssert.flatExtracting(String propertyName)	Extract from array's elements the Iterable/Array values corresponding to the given property/field name and concatenate them into a single array becoming the new object under test.
<U, C extends Collection<U>> ObjectArrayAssert<U>	AtomicReferenceArrayAssert.flatExtracting(Extractor<? super T,C> extractor)	Extract the Iterable values from the array's elements by applying an Iterable extracting function on them and concatenating the result lists into an array which becomes the new object under test.
<U, C extends Collection<U>, EXCEPTION extends Exception> ObjectArrayAssert<U>	AtomicReferenceArrayAssert.flatExtracting(ThrowingExtractor<? super T,C,EXCEPTION> extractor)	Extract the Iterable values from the array's elements by applying an Iterable extracting function (which might throw an exception) on them and concatenating the result lists into an array which becomes the new object under test.
<U> AbstractOptionalAssert<?,U>	AbstractOptionalAssert.flatMap(Function<? super VALUE,Optional<U>> mapper)	Call flatMap on the Optional under test, assertions chained afterwards are performed on the Optional resulting from the flatMap call.
protected SELF	AbstractAssert.inBinary()	Use binary object representation instead of standard representation in error messages.
SELF	AbstractComparableAssert.inBinary()
SELF	AbstractEnumerableAssert.inBinary()
SELF	AbstractIterableAssert.inBinary()	Enable binary representation of Iterable elements instead of standard representation in error messages.
SELF	AbstractObjectArrayAssert.inBinary()
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.inBinary()
protected SELF	AbstractAssert.inHexadecimal()	Use hexadecimal object representation instead of standard representation in error messages.
SELF	AbstractCharSequenceAssert.inHexadecimal()
SELF	AbstractComparableAssert.inHexadecimal()
SELF	AbstractEnumerableAssert.inHexadecimal()	Enable hexadecimal object representation of Iterable elements instead of standard java representation in error messages.
SELF	AbstractIterableAssert.inHexadecimal()	Enable hexadecimal representation of Iterable elements instead of standard representation in error messages.
SELF	AbstractObjectArrayAssert.inHexadecimal()	Enable hexadecimal object representation of Iterable elements instead of standard java representation in error messages.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.inHexadecimal()	Enable hexadecimal object representation of Iterable elements instead of standard java representation in error messages.
SELF	AbstractCharacterAssert.inUnicode()	Use unicode character representation instead of standard representation in error messages.
SELF	AbstractCharArrayAssert.inUnicode()	Use unicode character representation instead of standard representation in error messages.
SELF	AbstractCharSequenceAssert.inUnicode()	Use unicode character representation instead of standard representation in error messages.
ELEMENT_ASSERT	AbstractIterableAssert.last()	Navigate and allow to perform assertions on the first element of the Iterable under test.
<U> AbstractOptionalAssert<?,U>	AbstractOptionalAssert.map(Function<? super VALUE,? extends U> mapper)	Call map on the Optional under test, assertions chained afterwards are performed on the Optional resulting from the map call.
SELF	AbstractAssert.overridingErrorMessage(String newErrorMessage, Object... args)	Overrides AssertJ default error message by the given one.
SELF	AbstractIterableAssert.overridingErrorMessage(String newErrorMessage, Object... args)
SELF	AbstractListAssert.overridingErrorMessage(String newErrorMessage, Object... args)
SELF	AbstractMapAssert.overridingErrorMessage(String newErrorMessage, Object... args)
AbstractIterableAssert<IterableAssert<T>,Iterable<? extends T>,T,ObjectAssert<T>>	IterableSizeAssert.returnToIterable()
AbstractMapAssert<MapAssert<KEY,VALUE>,Map<KEY,VALUE>,KEY,VALUE>	MapSizeAssert.returnToMap()
AbstractIterableSizeAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>	AbstractIterableAssert.size()	Returns an Assert object that allows performing assertions on the size of the Iterable under test.
AbstractMapSizeAssert<SELF,ACTUAL,K,V>	AbstractMapAssert.size()	Returns an Assert object that allows performing assertions on the size of the Map under test.
PathAssert	AbstractBDDSoftAssertions.then(Path actual)	Creates a new, proxied instance of a PathAssert
InstantAssert	AbstractBDDSoftAssertions.then(Instant actual)	Creates a new instance of InstantAssert.
LocalDateAssert	AbstractBDDSoftAssertions.then(LocalDate actual)	Creates a new instance of LocalDateAssert.
LocalDateTimeAssert	AbstractBDDSoftAssertions.then(LocalDateTime actual)	Creates a new instance of LocalDateTimeAssert.
LocalTimeAssert	AbstractBDDSoftAssertions.then(LocalTime actual)	Creates a new instance of LocalTimeAssert.
OffsetDateTimeAssert	AbstractBDDSoftAssertions.then(OffsetDateTime actual)	Creates a new instance of OffsetDateTimeAssert.
OffsetTimeAssert	AbstractBDDSoftAssertions.then(OffsetTime actual)	Creates a new instance of OffsetTimeAssert.
ZonedDateTimeAssert	AbstractBDDSoftAssertions.then(ZonedDateTime actual)	Creates a new instance of ZonedDateTimeAssert.
<RESULT> CompletableFutureAssert<RESULT>	AbstractBDDSoftAssertions.then(CompletableFuture<RESULT> actual)	Create assertion for CompletableFuture.
DoublePredicateAssert	AbstractBDDSoftAssertions.then(DoublePredicate actual)	Create assertion for DoublePredicate.
IntPredicateAssert	AbstractBDDSoftAssertions.then(IntPredicate actual)	Create assertion for IntPredicate.
LongPredicateAssert	AbstractBDDSoftAssertions.then(LongPredicate actual)	Create assertion for DoublePredicate.
<T> SoftAssertionPredicateAssert<T>	AbstractBDDSoftAssertions.then(Predicate<T> actual)	Create assertion for Predicate.
<VALUE> OptionalAssert<VALUE>	AbstractBDDSoftAssertions.then(Optional<VALUE> actual)	Create assertion for Optional.
OptionalDoubleAssert	AbstractBDDSoftAssertions.then(OptionalDouble actual)	Create assertion for OptionalDouble.
OptionalIntAssert	AbstractBDDSoftAssertions.then(OptionalInt actual)	Create assertion for OptionalInt.
OptionalLongAssert	AbstractBDDSoftAssertions.then(OptionalLong actual)	Create assertion for OptionalLong.
<ELEMENT, STREAM extends BaseStream<ELEMENT, STREAM>> ListAssert<ELEMENT>	AbstractBDDSoftAssertions.then(BaseStream<? extends ELEMENT,STREAM> actual)	Creates a new instance of ListAssert from the given BaseStream.
static AbstractBooleanAssert<?>	BDDAssertions.then(boolean actual)	Creates a new instance of BooleanAssert.
static AbstractBooleanArrayAssert<?>	BDDAssertions.then(boolean[] actual)	Creates a new instance of BooleanArrayAssert.
static AbstractByteAssert<?>	BDDAssertions.then(byte actual)	Creates a new instance of ByteAssert.
static AbstractByteArrayAssert<?>	BDDAssertions.then(byte[] actual)	Creates a new instance of ByteArrayAssert.
static AbstractCharacterAssert<?>	BDDAssertions.then(char actual)	Creates a new instance of CharacterAssert.
static AbstractCharArrayAssert<?>	BDDAssertions.then(char[] actual)	Creates a new instance of CharArrayAssert.
static AbstractDoubleAssert<?>	BDDAssertions.then(double actual)	Creates a new instance of DoubleAssert.
static AbstractDoubleArrayAssert<?>	BDDAssertions.then(double[] actual)	Creates a new instance of DoubleArrayAssert.
static AbstractFloatAssert<?>	BDDAssertions.then(float actual)	Creates a new instance of FloatAssert.
static AbstractFloatArrayAssert<?>	BDDAssertions.then(float[] actual)	Creates a new instance of FloatArrayAssert.
static AbstractIntegerAssert<?>	BDDAssertions.then(int actual)	Creates a new instance of IntegerAssert.
static AbstractIntArrayAssert<?>	BDDAssertions.then(int[] actual)	Creates a new instance of IntArrayAssert.
static AbstractLongAssert<?>	BDDAssertions.then(long actual)	Creates a new instance of LongAssert.
static AbstractLongArrayAssert<?>	BDDAssertions.then(long[] actual)	Creates a new instance of LongArrayAssert.
static AbstractShortAssert<?>	BDDAssertions.then(short actual)	Creates a new instance of ShortAssert.
static AbstractShortArrayAssert<?>	BDDAssertions.then(short[] actual)	Creates a new instance of ShortArrayAssert.
static AbstractFileAssert<?>	BDDAssertions.then(File actual)	Creates a new instance of FileAssert.
static AbstractInputStreamAssert<?,? extends InputStream>	BDDAssertions.then(InputStream actual)	Creates a new instance of InputStreamAssert.
static AbstractBooleanAssert<?>	BDDAssertions.then(Boolean actual)	Creates a new instance of BooleanAssert.
static AbstractByteAssert<?>	BDDAssertions.then(Byte actual)	Creates a new instance of ByteAssert.
static AbstractCharacterAssert<?>	BDDAssertions.then(Character actual)	Creates a new instance of CharacterAssert.
static AbstractCharSequenceAssert<?,? extends CharSequence>	BDDAssertions.then(CharSequence actual)	Creates a new instance of CharSequenceAssert.
static AbstractClassAssert<?>	BDDAssertions.then(Class<?> actual)	Creates a new instance of ClassAssert
static AbstractDoubleAssert<?>	BDDAssertions.then(Double actual)	Creates a new instance of DoubleAssert.
static AbstractFloatAssert<?>	BDDAssertions.then(Float actual)	Creates a new instance of FloatAssert.
static AbstractIntegerAssert<?>	BDDAssertions.then(Integer actual)	Creates a new instance of IntegerAssert.
static <T> IterableAssert<T>	BDDAssertions.then(Iterable<? extends T> actual)	Creates a new instance of IterableAssert.
static AbstractLongAssert<?>	BDDAssertions.then(Long actual)	Creates a new instance of LongAssert.
static AbstractShortAssert<?>	BDDAssertions.then(Short actual)	Creates a new instance of ShortAssert.
static AbstractCharSequenceAssert<?,String>	BDDAssertions.then(String actual)	Creates a new instance of StringAssert.
static AbstractThrowableAssert<?,? extends Throwable>	BDDAssertions.then(Throwable actual)	Creates a new instance of ThrowableAssert.
static AbstractBigDecimalAssert<?>	BDDAssertions.then(BigDecimal actual)	Creates a new instance of BigDecimalAssert.
static AbstractBigIntegerAssert<?>	BDDAssertions.then(BigInteger actual)	Creates a new instance of BigIntegerAssert.
static AbstractUriAssert<?>	BDDAssertions.then(URI actual)	Creates a new instance of UriAssert.
static AbstractUrlAssert<?>	BDDAssertions.then(URL actual)	Creates a new instance of UrlAssert.
static AbstractPathAssert<?>	BDDAssertions.then(Path actual)	Creates a new instance of PathAssert
static AbstractInstantAssert<?>	BDDAssertions.then(Instant actual)	Creates a new instance of InstantAssert.
static AbstractLocalDateAssert<?>	BDDAssertions.then(LocalDate actual)	Creates a new instance of LocalDateAssert.
static AbstractLocalDateTimeAssert<?>	BDDAssertions.then(LocalDateTime actual)	Creates a new instance of LocalDateTimeAssert.
static AbstractLocalTimeAssert<?>	BDDAssertions.then(LocalTime actual)	Creates a new instance of LocalTimeAssert.
static AbstractOffsetDateTimeAssert<?>	BDDAssertions.then(OffsetDateTime actual)	Creates a new instance of OffsetTimeAssert.
static AbstractOffsetTimeAssert<?>	BDDAssertions.then(OffsetTime actual)	Creates a new instance of OffsetTimeAssert.
static AbstractZonedDateTimeAssert<?>	BDDAssertions.then(ZonedDateTime actual)	Creates a new instance of ZonedDateTimeAssert.
static AtomicBooleanAssert	BDDAssertions.then(AtomicBoolean actual)	Create assertion for AtomicBoolean.
static AtomicIntegerAssert	BDDAssertions.then(AtomicInteger actual)	Create assertion for AtomicInteger.
static AtomicIntegerArrayAssert	BDDAssertions.then(AtomicIntegerArray actual)	Create assertion for AtomicIntegerArray.
static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT>	BDDAssertions.then(AtomicIntegerFieldUpdater<OBJECT> actual)	Create assertion for AtomicIntegerFieldUpdater.
static AtomicLongAssert	BDDAssertions.then(AtomicLong actual)	Create assertion for AtomicLong.
static AtomicLongArrayAssert	BDDAssertions.then(AtomicLongArray actual)	Create assertion for AtomicLongArray.
static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT>	BDDAssertions.then(AtomicLongFieldUpdater<OBJECT> actual)	Create assertion for AtomicLongFieldUpdater.
static <VALUE> AtomicMarkableReferenceAssert<VALUE>	BDDAssertions.then(AtomicMarkableReference<VALUE> actual)	Create assertion for AtomicMarkableReference.
static <VALUE> AtomicReferenceAssert<VALUE>	BDDAssertions.then(AtomicReference<VALUE> actual)	Create assertion for AtomicReference.
static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	BDDAssertions.then(AtomicReferenceArray<ELEMENT> actual)	Create assertion for AtomicReferenceArray.
static <FIELD, OBJECT> AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT>	BDDAssertions.then(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)	Create assertion for AtomicReferenceFieldUpdater.
static <VALUE> AtomicStampedReferenceAssert<VALUE>	BDDAssertions.then(AtomicStampedReference<VALUE> actual)	Create assertion for AtomicStampedReference.
static <RESULT> CompletableFutureAssert<RESULT>	BDDAssertions.then(CompletableFuture<RESULT> future)	Create assertion for CompletableFuture.
static <RESULT> AbstractFutureAssert<?,? extends Future<? extends RESULT>,RESULT>	BDDAssertions.then(Future<RESULT> actual)	Creates a new instance of FutureAssert
static AbstractDateAssert<?>	BDDAssertions.then(Date actual)	Creates a new instance of DateAssert.
static DoublePredicateAssert	BDDAssertions.then(DoublePredicate actual)	Create assertion for DoublePredicate.
static IntPredicateAssert	BDDAssertions.then(IntPredicate actual)	Create assertion for IntPredicate.
static LongPredicateAssert	BDDAssertions.then(LongPredicate actual)	Create assertion for LongPredicate.
static <T> PredicateAssert<T>	BDDAssertions.then(Predicate<T> actual)	Create assertion for Predicate.
static <T> IterableAssert<T>	BDDAssertions.then(Iterator<? extends T> actual)	Creates a new instance of IterableAssert.
static <T> ListAssert<T>	BDDAssertions.then(List<? extends T> actual)	Creates a new instance of ListAssert.
static <K, V> MapAssert<K,V>	BDDAssertions.then(Map<K,V> actual)	Creates a new instance of MapAssert.
static <VALUE> OptionalAssert<VALUE>	BDDAssertions.then(Optional<VALUE> optional)	Create assertion for Optional.
static OptionalDoubleAssert	BDDAssertions.then(OptionalDouble optional)	Create assertion for OptionalDouble.
static OptionalIntAssert	BDDAssertions.then(OptionalInt optional)	Create assertion for OptionalInt.
static OptionalLongAssert	BDDAssertions.then(OptionalLong optional)	Create assertion for OptionalLong.
static <ELEMENT, STREAM extends BaseStream<ELEMENT, STREAM>> AbstractListAssert<?,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>	BDDAssertions.then(BaseStream<? extends ELEMENT,STREAM> actual)	Creates a new instance of ListAssert from the given BaseStream.
static <T extends Comparable<? super T>> AbstractComparableAssert<?,T>	BDDAssertions.then(T actual)	Creates a new instance of GenericComparableAssert with standard comparison semantics.
static <T> AbstractObjectAssert<?,T>	BDDAssertions.then(T actual)	Creates a new instance of ObjectAssert.
static <T extends AssertDelegateTarget> T	BDDAssertions.then(T assertion)	Returns the given assertion.
static <T> AbstractObjectArrayAssert<?,T>	BDDAssertions.then(T[] actual)	Creates a new instance of ObjectArrayAssert.
BooleanAssert	Java6AbstractBDDSoftAssertions.then(boolean actual)	Creates a new instance of BooleanAssert.
BooleanArrayAssert	Java6AbstractBDDSoftAssertions.then(boolean[] actual)	Creates a new instance of BooleanArrayAssert.
ByteAssert	Java6AbstractBDDSoftAssertions.then(byte actual)	Creates a new instance of ByteAssert.
ByteArrayAssert	Java6AbstractBDDSoftAssertions.then(byte[] actual)	Creates a new instance of ByteArrayAssert.
CharacterAssert	Java6AbstractBDDSoftAssertions.then(char actual)	Creates a new instance of CharacterAssert.
CharArrayAssert	Java6AbstractBDDSoftAssertions.then(char[] actual)	Creates a new instance of CharArrayAssert.
DoubleAssert	Java6AbstractBDDSoftAssertions.then(double actual)	Creates a new instance of DoubleAssert.
DoubleArrayAssert	Java6AbstractBDDSoftAssertions.then(double[] actual)	Creates a new instance of DoubleArrayAssert.
FloatAssert	Java6AbstractBDDSoftAssertions.then(float actual)	Creates a new instance of FloatAssert.
FloatArrayAssert	Java6AbstractBDDSoftAssertions.then(float[] actual)	Creates a new instance of FloatArrayAssert.
IntegerAssert	Java6AbstractBDDSoftAssertions.then(int actual)	Creates a new instance of IntegerAssert.
IntArrayAssert	Java6AbstractBDDSoftAssertions.then(int[] actual)	Creates a new instance of IntArrayAssert.
LongAssert	Java6AbstractBDDSoftAssertions.then(long actual)	Creates a new instance of LongAssert.
LongArrayAssert	Java6AbstractBDDSoftAssertions.then(long[] actual)	Creates a new instance of LongArrayAssert.
ShortAssert	Java6AbstractBDDSoftAssertions.then(short actual)	Creates a new instance of ShortAssert.
ShortArrayAssert	Java6AbstractBDDSoftAssertions.then(short[] actual)	Creates a new instance of ShortArrayAssert.
FileAssert	Java6AbstractBDDSoftAssertions.then(File actual)	Creates a new instance of FileAssert.
InputStreamAssert	Java6AbstractBDDSoftAssertions.then(InputStream actual)	Creates a new instance of InputStreamAssert.
BooleanAssert	Java6AbstractBDDSoftAssertions.then(Boolean actual)	Creates a new instance of BooleanAssert.
ByteAssert	Java6AbstractBDDSoftAssertions.then(Byte actual)	Creates a new instance of ByteAssert.
CharacterAssert	Java6AbstractBDDSoftAssertions.then(Character actual)	Creates a new instance of CharacterAssert.
CharSequenceAssert	Java6AbstractBDDSoftAssertions.then(CharSequence actual)	Creates a new instance of CharSequenceAssert.
SoftAssertionClassAssert	Java6AbstractBDDSoftAssertions.then(Class<?> actual)	Creates a new instance of ClassAssert
DoubleAssert	Java6AbstractBDDSoftAssertions.then(Double actual)	Creates a new instance of DoubleAssert.
FloatAssert	Java6AbstractBDDSoftAssertions.then(Float actual)	Creates a new instance of FloatAssert.
IntegerAssert	Java6AbstractBDDSoftAssertions.then(Integer actual)	Creates a new instance of IntegerAssert.
<T> SoftAssertionIterableAssert<T>	Java6AbstractBDDSoftAssertions.then(Iterable<? extends T> actual)	Creates a new instance of IterableAssert.
LongAssert	Java6AbstractBDDSoftAssertions.then(Long actual)	Creates a new instance of LongAssert.
ShortAssert	Java6AbstractBDDSoftAssertions.then(Short actual)	Creates a new instance of ShortAssert.
StringAssert	Java6AbstractBDDSoftAssertions.then(String actual)	Creates a new instance of StringAssert.
ThrowableAssert	Java6AbstractBDDSoftAssertions.then(Throwable actual)	Creates a new instance of ThrowableAssert.
BigDecimalAssert	Java6AbstractBDDSoftAssertions.then(BigDecimal actual)	Creates a new instance of BigDecimalAssert.
BigIntegerAssert	Java6AbstractBDDSoftAssertions.then(BigInteger actual)	Creates a new instance of BigIntegerAssert.
UriAssert	Java6AbstractBDDSoftAssertions.then(URI actual)	Creates a new instance of UriAssert.
AbstractUrlAssert<?>	Java6AbstractBDDSoftAssertions.then(URL actual)	Creates a new instance of UrlAssert.
AtomicBooleanAssert	Java6AbstractBDDSoftAssertions.then(AtomicBoolean actual)	Create assertion for AtomicBoolean.
AtomicIntegerAssert	Java6AbstractBDDSoftAssertions.then(AtomicInteger actual)	Create assertion for AtomicInteger.
AtomicIntegerArrayAssert	Java6AbstractBDDSoftAssertions.then(AtomicIntegerArray actual)	Create assertion for AtomicIntegerArray.
<OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT>	Java6AbstractBDDSoftAssertions.then(AtomicIntegerFieldUpdater<OBJECT> actual)	Create assertion for AtomicIntegerFieldUpdater.
AtomicLongAssert	Java6AbstractBDDSoftAssertions.then(AtomicLong actual)	Create assertion for AtomicLong.
AtomicLongArrayAssert	Java6AbstractBDDSoftAssertions.then(AtomicLongArray actual)	Create assertion for AtomicLongArray.
<OBJECT> AtomicLongFieldUpdaterAssert<OBJECT>	Java6AbstractBDDSoftAssertions.then(AtomicLongFieldUpdater<OBJECT> actual)	Create assertion for AtomicLongFieldUpdater.
<VALUE> AtomicMarkableReferenceAssert<VALUE>	Java6AbstractBDDSoftAssertions.then(AtomicMarkableReference<VALUE> actual)	Create assertion for AtomicMarkableReference.
<VALUE> AtomicReferenceAssert<VALUE>	Java6AbstractBDDSoftAssertions.then(AtomicReference<VALUE> actual)	Create assertion for AtomicReference.
<ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	Java6AbstractBDDSoftAssertions.then(AtomicReferenceArray<ELEMENT> actual)	Create assertion for AtomicReferenceArray.
<FIELD, OBJECT> AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT>	Java6AbstractBDDSoftAssertions.then(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)	Create assertion for AtomicReferenceFieldUpdater.
<VALUE> AtomicStampedReferenceAssert<VALUE>	Java6AbstractBDDSoftAssertions.then(AtomicStampedReference<VALUE> actual)	Create assertion for AtomicStampedReference.
<RESULT> FutureAssert<RESULT>	Java6AbstractBDDSoftAssertions.then(Future<RESULT> actual)	Creates a new instance of FutureAssert.
DateAssert	Java6AbstractBDDSoftAssertions.then(Date actual)	Creates a new instance of DateAssert.
<T> SoftAssertionIterableAssert<T>	Java6AbstractBDDSoftAssertions.then(Iterator<T> actual)	Creates a new instance of IterableAssert.
<T> SoftAssertionListAssert<T>	Java6AbstractBDDSoftAssertions.then(List<? extends T> actual)	Creates a new instance of ListAssert.
<K, V> SoftAssertionMapAssert<K,V>	Java6AbstractBDDSoftAssertions.then(Map<K,V> actual)	Creates a new instance of MapAssert.
<T extends Comparable<? super T>> AbstractComparableAssert<?,T>	Java6AbstractBDDSoftAssertions.then(T actual)	Creates a new instance of GenericComparableAssert with standard comparison semantics.
<T> ObjectAssert<T>	Java6AbstractBDDSoftAssertions.then(T actual)	Creates a new instance of ObjectAssert.
<T> ObjectArrayAssert<T>	Java6AbstractBDDSoftAssertions.then(T[] actual)	Creates a new instance of ObjectArrayAssert.
static AbstractBooleanAssert<?>	Java6BDDAssertions.then(boolean actual)	Creates a new instance of BooleanAssert.
static AbstractBooleanArrayAssert<?>	Java6BDDAssertions.then(boolean[] actual)	Creates a new instance of BooleanArrayAssert.
static AbstractByteAssert<?>	Java6BDDAssertions.then(byte actual)	Creates a new instance of ByteAssert.
static AbstractByteArrayAssert<?>	Java6BDDAssertions.then(byte[] actual)	Creates a new instance of ByteArrayAssert.
static AbstractCharacterAssert<?>	Java6BDDAssertions.then(char actual)	Creates a new instance of CharacterAssert.
static AbstractCharArrayAssert<?>	Java6BDDAssertions.then(char[] actual)	Creates a new instance of CharArrayAssert.
static AbstractDoubleAssert<?>	Java6BDDAssertions.then(double actual)	Creates a new instance of DoubleAssert.
static AbstractDoubleArrayAssert<?>	Java6BDDAssertions.then(double[] actual)	Creates a new instance of DoubleArrayAssert.
static AbstractFloatAssert<?>	Java6BDDAssertions.then(float actual)	Creates a new instance of FloatAssert.
static AbstractFloatArrayAssert<?>	Java6BDDAssertions.then(float[] actual)	Creates a new instance of FloatArrayAssert.
static AbstractIntegerAssert<?>	Java6BDDAssertions.then(int actual)	Creates a new instance of IntegerAssert.
static AbstractIntArrayAssert<?>	Java6BDDAssertions.then(int[] actual)	Creates a new instance of IntArrayAssert.
static AbstractLongAssert<?>	Java6BDDAssertions.then(long actual)	Creates a new instance of LongAssert.
static AbstractLongArrayAssert<?>	Java6BDDAssertions.then(long[] actual)	Creates a new instance of LongArrayAssert.
static AbstractShortAssert<?>	Java6BDDAssertions.then(short actual)	Creates a new instance of ShortAssert.
static AbstractShortArrayAssert<?>	Java6BDDAssertions.then(short[] actual)	Creates a new instance of ShortArrayAssert.
static AbstractFileAssert<?>	Java6BDDAssertions.then(File actual)	Creates a new instance of FileAssert.
static AbstractInputStreamAssert<?,? extends InputStream>	Java6BDDAssertions.then(InputStream actual)	Creates a new instance of InputStreamAssert.
static AbstractBooleanAssert<?>	Java6BDDAssertions.then(Boolean actual)	Creates a new instance of BooleanAssert.
static AbstractByteAssert<?>	Java6BDDAssertions.then(Byte actual)	Creates a new instance of ByteAssert.
static AbstractCharacterAssert<?>	Java6BDDAssertions.then(Character actual)	Creates a new instance of CharacterAssert.
static AbstractCharSequenceAssert<?,? extends CharSequence>	Java6BDDAssertions.then(CharSequence actual)	Creates a new instance of CharSequenceAssert.
static AbstractClassAssert<?>	Java6BDDAssertions.then(Class<?> actual)	Creates a new instance of ClassAssert
static AbstractDoubleAssert<?>	Java6BDDAssertions.then(Double actual)	Creates a new instance of DoubleAssert.
static AbstractFloatAssert<?>	Java6BDDAssertions.then(Float actual)	Creates a new instance of FloatAssert.
static AbstractIntegerAssert<?>	Java6BDDAssertions.then(Integer actual)	Creates a new instance of IntegerAssert.
static <T> AbstractIterableAssert<?,Iterable<? extends T>,T,ObjectAssert<T>>	Java6BDDAssertions.then(Iterable<? extends T> actual)	Creates a new instance of IterableAssert.
static AbstractLongAssert<?>	Java6BDDAssertions.then(Long actual)	Creates a new instance of LongAssert.
static AbstractShortAssert<?>	Java6BDDAssertions.then(Short actual)	Creates a new instance of ShortAssert.
static AbstractCharSequenceAssert<?,String>	Java6BDDAssertions.then(String actual)	Creates a new instance of StringAssert.
static AbstractThrowableAssert<?,? extends Throwable>	Java6BDDAssertions.then(Throwable actual)	Creates a new instance of ThrowableAssert.
static AbstractBigDecimalAssert<?>	Java6BDDAssertions.then(BigDecimal actual)	Creates a new instance of BigDecimalAssert.
static AbstractBigIntegerAssert<?>	Java6BDDAssertions.then(BigInteger actual)	Creates a new instance of BigIntegerAssert.
static AbstractUriAssert<?>	Java6BDDAssertions.then(URI actual)	Creates a new instance of UriAssert.
static AbstractUrlAssert<?>	Java6BDDAssertions.then(URL actual)	Creates a new instance of UrlAssert.
static AtomicBooleanAssert	Java6BDDAssertions.then(AtomicBoolean actual)	Create assertion for AtomicBoolean.
static AtomicIntegerAssert	Java6BDDAssertions.then(AtomicInteger actual)	Create assertion for AtomicInteger.
static AtomicIntegerArrayAssert	Java6BDDAssertions.then(AtomicIntegerArray actual)	Create int[] assertion for AtomicIntegerArray.
static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT>	Java6BDDAssertions.then(AtomicIntegerFieldUpdater<OBJECT> actual)	Create assertion for AtomicIntegerFieldUpdater.
static AtomicLongAssert	Java6BDDAssertions.then(AtomicLong actual)	Create assertion for AtomicLong.
static AtomicLongArrayAssert	Java6BDDAssertions.then(AtomicLongArray actual)	Create assertion for AtomicLongArray.
static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT>	Java6BDDAssertions.then(AtomicLongFieldUpdater<OBJECT> actual)	Create assertion for AtomicLongFieldUpdater.
static <VALUE> AtomicMarkableReferenceAssert<VALUE>	Java6BDDAssertions.then(AtomicMarkableReference<VALUE> actual)	Create assertion for AtomicMarkableReference.
static <VALUE> AtomicReferenceAssert<VALUE>	Java6BDDAssertions.then(AtomicReference<VALUE> actual)	Create assertion for AtomicReference.
static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	Java6BDDAssertions.then(AtomicReferenceArray<ELEMENT> actual)	Create assertion for AtomicReferenceArray.
static <FIELD, OBJECT> AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT>	Java6BDDAssertions.then(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)	Create assertion for AtomicReferenceFieldUpdater.
static <VALUE> AtomicStampedReferenceAssert<VALUE>	Java6BDDAssertions.then(AtomicStampedReference<VALUE> actual)	Create assertion for AtomicStampedReference.
static <RESULT> AbstractFutureAssert<?,? extends Future<? extends RESULT>,RESULT>	Java6BDDAssertions.then(Future<RESULT> actual)	Creates a new instance of FutureAssert.
static AbstractDateAssert<?>	Java6BDDAssertions.then(Date actual)	Creates a new instance of DateAssert.
static <T> AbstractIterableAssert<?,Iterable<? extends T>,T,ObjectAssert<T>>	Java6BDDAssertions.then(Iterator<? extends T> actual)	Creates a new instance of IterableAssert.
static <T> AbstractListAssert<?,List<? extends T>,T,ObjectAssert<T>>	Java6BDDAssertions.then(List<? extends T> actual)	Creates a new instance of ListAssert.
static <K, V> MapAssert<K,V>	Java6BDDAssertions.then(Map<K,V> actual)	Creates a new instance of MapAssert.
static <T extends Comparable<? super T>> AbstractComparableAssert<?,T>	Java6BDDAssertions.then(T actual)	Creates a new instance of GenericComparableAssert with standard comparison semantics.
static <T> AbstractObjectAssert<?,T>	Java6BDDAssertions.then(T actual)	Creates a new instance of ObjectAssert.
static <T extends AssertDelegateTarget> T	Java6BDDAssertions.then(T assertion)	Returns the given assertion.
static <T> AbstractObjectArrayAssert<?,T>	Java6BDDAssertions.then(T[] actual)	Creates a new instance of ObjectArrayAssert.
static AbstractThrowableAssert<?,? extends Throwable>	BDDAssertions.thenCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)	Allows to capture and then assert on a Throwable more easily when used with Java 8 lambdas.
AbstractThrowableAssert<?,? extends Throwable>	Java6AbstractBDDSoftAssertions.thenCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)	Allows to capture and then assert on a Throwable more easily when used with Java 8 lambdas.
static AbstractThrowableAssert<?,? extends Throwable>	BDDAssertions.thenThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)	Allows to capture and then assert on a Throwable more easily when used with Java 8 lambdas.
AbstractThrowableAssert<?,? extends Throwable>	Java6AbstractBDDSoftAssertions.thenThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)	Allows to capture and then assert on a Throwable more easily when used with Java 8 lambdas.
static AbstractThrowableAssert<?,? extends Throwable>	Java6BDDAssertions.thenThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)	Allows to capture and then assert on a Throwable more easily when used with Java 8 lambdas.
SELF	AbstractFileAssert.usingCharset(String charsetName)	Specifies the name of the charset to use for text-based assertions on the file's contents.
SELF	AbstractFileAssert.usingCharset(Charset charset)	Specifies the charset to use for text-based assertions on the file's contents.
SELF	AbstractPathAssert.usingCharset(String charsetName)	Specifies the name of the charset to use for text-based assertions on the path's contents (path must be a readable file).
SELF	AbstractPathAssert.usingCharset(Charset charset)	Specifies the charset to use for text-based assertions on the path's contents (path must be a readable file).
SELF	AbstractAssert.usingComparator(Comparator<? super ACTUAL> customComparator)	Use given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
SELF	AbstractBigDecimalAssert.usingComparator(Comparator<? super BigDecimal> customComparator)
SELF	AbstractBigIntegerAssert.usingComparator(Comparator<? super BigInteger> customComparator)
SELF	AbstractByteAssert.usingComparator(Comparator<? super Byte> customComparator)
SELF	AbstractCharacterAssert.usingComparator(Comparator<? super Character> customComparator)
SELF	AbstractCharSequenceAssert.usingComparator(Comparator<? super ACTUAL> customComparator)
SELF	AbstractComparableAssert.usingComparator(Comparator<? super ACTUAL> customComparator)
SELF	AbstractDateAssert.usingComparator(Comparator<? super Date> customComparator)
SELF	AbstractDoubleAssert.usingComparator(Comparator<? super Double> customComparator)
SELF	AbstractFloatAssert.usingComparator(Comparator<? super Float> customComparator)
SELF	AbstractIntegerAssert.usingComparator(Comparator<? super Integer> customComparator)
SELF	AbstractIterableAssert.usingComparator(Comparator<? super ACTUAL> customComparator)
SELF	AbstractListAssert.usingComparator(Comparator<? super ACTUAL> customComparator)
SELF	AbstractLongAssert.usingComparator(Comparator<? super Long> customComparator)
SELF	AbstractMapAssert.usingComparator(Comparator<? super ACTUAL> customComparator)
SELF	AbstractShortAssert.usingComparator(Comparator<? super Short> customComparator)
AtomicIntegerAssert	AtomicIntegerAssert.usingComparator(Comparator<? super AtomicInteger> customComparator)
AtomicLongAssert	AtomicLongAssert.usingComparator(Comparator<? super AtomicLong> customComparator)
<T> SELF	AbstractIterableAssert.usingComparatorForElementFieldsWithNames(Comparator<T> comparator, String... elementPropertyOrFieldNames)	Allows to set a comparator to compare properties or fields of elements with the given names.
<C> SELF	AbstractObjectArrayAssert.usingComparatorForElementFieldsWithNames(Comparator<C> comparator, String... elementPropertyOrFieldNames)	Allows to set a comparator to compare properties or fields of elements with the given names.
<C> AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingComparatorForElementFieldsWithNames(Comparator<C> comparator, String... elementPropertyOrFieldNames)	Allows to set a comparator to compare properties or fields of elements with the given names.
<T> SELF	AbstractIterableAssert.usingComparatorForElementFieldsWithType(Comparator<T> comparator, Class<T> type)	Allows to set a specific comparator to compare properties or fields of elements with the given type.
<C> SELF	AbstractObjectArrayAssert.usingComparatorForElementFieldsWithType(Comparator<C> comparator, Class<C> type)	Allows to set a specific comparator to compare properties or fields of elements with the given type.
<C> AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingComparatorForElementFieldsWithType(Comparator<C> comparator, Class<C> type)	Allows to set a specific comparator to compare properties or fields of elements with the given type.
<T> SELF	AbstractObjectAssert.usingComparatorForFields(Comparator<T> comparator, String... propertiesOrFields)	Allows to set a specific comparator to compare properties or fields with the given names.
<T> SELF	AbstractObjectAssert.usingComparatorForType(Comparator<T> comparator, Class<T> type)	Allows to set a specific comparator to compare properties or fields with the given type.
SELF	AbstractDoubleArrayAssert.usingComparatorWithPrecision(Double precision)	Create a Double comparator which compares double at the given precision and pass it to AbstractDoubleArrayAssert.usingElementComparator(Comparator).
SELF	AbstractFloatArrayAssert.usingComparatorWithPrecision(Float precision)	Create a Float comparator which compares floats at the given precision and pass it to AbstractFloatArrayAssert.usingElementComparator(Comparator).
SELF	AbstractAssert.usingDefaultComparator()	Revert to standard comparison for incoming assertion checks.
SELF	AbstractBigDecimalAssert.usingDefaultComparator()
SELF	AbstractBigIntegerAssert.usingDefaultComparator()
SELF	AbstractByteAssert.usingDefaultComparator()
SELF	AbstractCharacterAssert.usingDefaultComparator()
SELF	AbstractCharSequenceAssert.usingDefaultComparator()
SELF	AbstractComparableAssert.usingDefaultComparator()
SELF	AbstractDateAssert.usingDefaultComparator()
SELF	AbstractDoubleAssert.usingDefaultComparator()
SELF	AbstractFloatAssert.usingDefaultComparator()
SELF	AbstractIntegerAssert.usingDefaultComparator()
SELF	AbstractIterableAssert.usingDefaultComparator()
SELF	AbstractListAssert.usingDefaultComparator()
SELF	AbstractLongAssert.usingDefaultComparator()
SELF	AbstractMapAssert.usingDefaultComparator()
SELF	AbstractShortAssert.usingDefaultComparator()
AtomicIntegerAssert	AtomicIntegerAssert.usingDefaultComparator()
AtomicLongAssert	AtomicLongAssert.usingDefaultComparator()
SELF	AbstractByteArrayAssert.usingDefaultElementComparator()	Revert to standard comparison for incoming assertion group element checks.
SELF	AbstractCharArrayAssert.usingDefaultElementComparator()	Revert to standard comparison for incoming assertion group element checks.
SELF	AbstractDoubleArrayAssert.usingDefaultElementComparator()	Revert to standard comparison for incoming assertion group element checks.
SELF	AbstractFloatArrayAssert.usingDefaultElementComparator()	Revert to standard comparison for incoming assertion group element checks.
SELF	AbstractIntArrayAssert.usingDefaultElementComparator()	Revert to standard comparison for incoming assertion group element checks.
SELF	AbstractIterableAssert.usingDefaultElementComparator()	Revert to standard comparison for incoming assertion group element checks.
SELF	AbstractListAssert.usingDefaultElementComparator()
SELF	AbstractLongArrayAssert.usingDefaultElementComparator()	Revert to standard comparison for incoming assertion group element checks.
SELF	AbstractObjectArrayAssert.usingDefaultElementComparator()	Revert to standard comparison for incoming assertion group element checks.
SELF	AbstractShortArrayAssert.usingDefaultElementComparator()	Revert to standard comparison for incoming assertion group element checks.
AtomicIntegerArrayAssert	AtomicIntegerArrayAssert.usingDefaultElementComparator()	Revert to standard comparison for incoming assertion group element checks.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingDefaultElementComparator()	Revert to standard comparison for incoming assertion group element checks.
SELF	AbstractOptionalAssert.usingDefaultValueComparator()	Revert to standard comparison for incoming assertion Optional value checks.
SELF	AbstractByteArrayAssert.usingElementComparator(Comparator<? super Byte> customComparator)	Use given custom comparator instead of relying on actual type A equals method to compare group elements for incoming assertion checks.
SELF	AbstractCharArrayAssert.usingElementComparator(Comparator<? super Character> customComparator)	Use given custom comparator instead of relying on actual type A equals method to compare group elements for incoming assertion checks.
SELF	AbstractDoubleArrayAssert.usingElementComparator(Comparator<? super Double> customComparator)	Use given custom comparator instead of relying on actual type A equals method to compare group elements for incoming assertion checks.
SELF	AbstractFloatArrayAssert.usingElementComparator(Comparator<? super Float> customComparator)	Use given custom comparator instead of relying on actual type A equals method to compare group elements for incoming assertion checks.
SELF	AbstractIntArrayAssert.usingElementComparator(Comparator<? super Integer> customComparator)	Use given custom comparator instead of relying on actual type A equals method to compare group elements for incoming assertion checks.
SELF	AbstractIterableAssert.usingElementComparator(Comparator<? super ELEMENT> elementComparator)	Use given custom comparator instead of relying on actual type A equals method to compare group elements for incoming assertion checks.
SELF	AbstractListAssert.usingElementComparator(Comparator<? super ELEMENT> customComparator)
SELF	AbstractLongArrayAssert.usingElementComparator(Comparator<? super Long> customComparator)	Use given custom comparator instead of relying on actual type A equals method to compare group elements for incoming assertion checks.
SELF	AbstractObjectArrayAssert.usingElementComparator(Comparator<? super ELEMENT> elementComparator)	Use given custom comparator instead of relying on actual type A equals method to compare group elements for incoming assertion checks.
SELF	AbstractShortArrayAssert.usingElementComparator(Comparator<? super Short> customComparator)	Use given custom comparator instead of relying on actual type A equals method to compare group elements for incoming assertion checks.
AtomicIntegerArrayAssert	AtomicIntegerArrayAssert.usingElementComparator(Comparator<? super Integer> customComparator)	Use given custom comparator instead of relying on Integer equals method to compare elements for incoming assertion checks.
AtomicLongArrayAssert	AtomicLongArrayAssert.usingElementComparator(Comparator<? super Long> customComparator)	Use given custom comparator instead of relying on Long equals method to compare elements for incoming assertion checks.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingElementComparator(Comparator<? super T> elementComparator)	Use given custom comparator instead of relying on actual element type equals method to compare AtomicReferenceArray elements for incoming assertion checks.
SELF	AbstractIterableAssert.usingElementComparatorIgnoringFields(String... fields)	Use field/property by field/property on all fields/properties except the given ones (including inherited fields/properties)instead of relying on actual type A equals method to compare group elements for incoming assertion checks.
SELF	AbstractObjectArrayAssert.usingElementComparatorIgnoringFields(String... fields)	Use field/property by field/property on all fields/properties except the given ones (including inherited fields/properties)instead of relying on actual type A equals method to compare group elements for incoming assertion checks.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingElementComparatorIgnoringFields(String... fields)	Use field/property by field/property on all fields/properties except the given ones (including inherited fields/properties)instead of relying on actual type A equals method to compare AtomicReferenceArray elements for incoming assertion checks.
SELF	AbstractIterableAssert.usingElementComparatorOnFields(String... fields)	Use field/property by field/property comparison on the given fields/properties only (including inherited fields/properties)instead of relying on actual type A equals method to compare group elements for incoming assertion checks.
SELF	AbstractObjectArrayAssert.usingElementComparatorOnFields(String... fields)	Use field/property by field/property comparison on the given fields/properties only (including inherited fields/properties)instead of relying on actual type A equals method to compare group elements for incoming assertion checks.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingElementComparatorOnFields(String... fields)	Use field/property by field/property comparison on the given fields/properties only (including inherited fields/properties)instead of relying on actual type A equals method to compare AtomicReferenceArray elements for incoming assertion checks.
SELF	AbstractIterableAssert.usingFieldByFieldElementComparator()	Use field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type A equals method to compare group elements for incoming assertion checks.
SELF	AbstractObjectArrayAssert.usingFieldByFieldElementComparator()	Use field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type A equals method to compare group elements for incoming assertion checks.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingFieldByFieldElementComparator()	Use field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type A equals method to compare AtomicReferenceArray elements for incoming assertion checks.
SELF	AbstractOptionalAssert.usingFieldByFieldValueComparator()	Use field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type A equals method to compare the Optional value's object for incoming assertion checks.
SELF	AbstractIterableAssert.usingRecursiveFieldByFieldElementComparator()	Use a recursive field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type equals method to compare group elements for incoming assertion checks.
SELF	AbstractObjectArrayAssert.usingRecursiveFieldByFieldElementComparator()	Use a recursive field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type A equals method to compare group elements for incoming assertion checks.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingRecursiveFieldByFieldElementComparator()	Use a recursive field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type A equals method to compare AtomicReferenceArray elements for incoming assertion checks.
SELF	AbstractOptionalAssert.usingValueComparator(Comparator<? super VALUE> customComparator)	Use given custom comparator instead of relying on actual type A equals method to compare the Optional value's object for incoming assertion checks.
SELF	AbstractDateAssert.withDateFormat(String userCustomDateFormatPattern)	Instead of using default date formats for the date String based Date assertions like AbstractDateAssert.isEqualTo(String), AssertJ is gonna use any date formats registered with one of these methods : this method AbstractDateAssert.withDateFormat(java.text.DateFormat) AbstractDateAssert.registerCustomDateFormat(java.text.DateFormat) AbstractDateAssert.registerCustomDateFormat(String)
SELF	AbstractDateAssert.withDateFormat(DateFormat userCustomDateFormat)	Instead of using default date formats for the date String based Date assertions like AbstractDateAssert.isEqualTo(String), AssertJ is gonna use any date formats registered with one of these methods : AbstractDateAssert.withDateFormat(String) this method AbstractDateAssert.registerCustomDateFormat(java.text.DateFormat) AbstractDateAssert.registerCustomDateFormat(String)
SELF	AbstractDateAssert.withDefaultDateFormatsOnly()	Remove all registered custom date formats => use only the defaults date formats to parse string as date.
SELF	AbstractAssert.withFailMessage(String newErrorMessage, Object... args)	Alternative method for AbstractAssert.overridingErrorMessage(java.lang.String, java.lang.Object...)
SELF	AbstractIterableAssert.withFailMessage(String newErrorMessage, Object... args)
SELF	AbstractListAssert.withFailMessage(String newErrorMessage, Object... args)
SELF	AbstractMapAssert.withFailMessage(String newErrorMessage, Object... args)
SELF	AbstractAssert.withRepresentation(Representation representation)	Use the given Representation to describe/represent values in AssertJ error messages.
SELF	AbstractAssert.withThreadDumpOnError()	In case of an assertion error, a thread dump will be printed to System.err.
SELF	AbstractIterableAssert.withThreadDumpOnError()
SELF	AbstractListAssert.withThreadDumpOnError()
SELF	AbstractMapAssert.withThreadDumpOnError()