Uses of Annotation Type
org.assertj.core.util.CheckReturnValue
Packages that use CheckReturnValue
-
Uses of CheckReturnValue in org.assertj.core.api
Classes in org.assertj.core.api with annotations of type CheckReturnValueModifier and TypeClassDescriptionclass
Entry point for assertion methods for different types.Methods in org.assertj.core.api with annotations of type CheckReturnValueModifier and TypeMethodDescriptionSets the description of the assertion that is going to be called after.AbstractAssert.as
(Description description) Sets the description of the assertion that is going to be called after.AbstractIterableAssert.as
(Description description) AbstractListAssert.as
(Description description) AbstractMapAssert.as
(Description description) AbstractObjectAssert.as
(Description description) AtomicReferenceArrayAssert.as
(Description description) 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.AbstractStandardSoftAssertions.assertThat
(Path actual) Creates a new, proxied instance of aPathAssert
AbstractStandardSoftAssertions.assertThat
(Instant actual) Creates a new instance of
.InstantAssert
AbstractStandardSoftAssertions.assertThat
(LocalDate actual) Creates a new instance of
.LocalDateAssert
AbstractStandardSoftAssertions.assertThat
(LocalDateTime actual) Creates a new instance of
.LocalDateTimeAssert
AbstractStandardSoftAssertions.assertThat
(LocalTime actual) Creates a new instance of
.LocalTimeAssert
AbstractStandardSoftAssertions.assertThat
(OffsetDateTime actual) Creates a new instance of
.OffsetDateTimeAssert
AbstractStandardSoftAssertions.assertThat
(OffsetTime actual) Creates a new instance of
.OffsetTimeAssert
AbstractStandardSoftAssertions.assertThat
(ZonedDateTime actual) Creates a new instance of
.ZonedDateTimeAssert
<RESULT> CompletableFutureAssert<RESULT>
AbstractStandardSoftAssertions.assertThat
(CompletableFuture<RESULT> actual) Create assertion forCompletableFuture
.AbstractStandardSoftAssertions.assertThat
(DoublePredicate actual) Create assertion forDoublePredicate
.AbstractStandardSoftAssertions.assertThat
(IntPredicate actual) Create assertion forIntPredicate
.AbstractStandardSoftAssertions.assertThat
(LongPredicate actual) Create assertion forDoublePredicate
.<T> SoftAssertionPredicateAssert<T>
AbstractStandardSoftAssertions.assertThat
(Predicate<T> actual) Create assertion forPredicate
.<VALUE> OptionalAssert<VALUE>
AbstractStandardSoftAssertions.assertThat
(Optional<VALUE> actual) Create assertion forOptional
.AbstractStandardSoftAssertions.assertThat
(OptionalDouble actual) Create assertion forOptionalDouble
.AbstractStandardSoftAssertions.assertThat
(OptionalInt actual) Create assertion forOptionalInt
.AbstractStandardSoftAssertions.assertThat
(OptionalLong actual) Create assertion forOptionalLong
.<ELEMENT,
STREAM extends BaseStream<ELEMENT, STREAM>>
ListAssert<ELEMENT>AbstractStandardSoftAssertions.assertThat
(BaseStream<? extends ELEMENT, STREAM> actual) Creates a new instance of
from the givenListAssert
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 ofClassAssert
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 ofPathAssert
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 forOffsetTime
.static AbstractZonedDateTimeAssert<?>
Assertions.assertThat
(ZonedDateTime actual) Creates a new instance of
.ZonedDateTimeAssert
static AtomicBooleanAssert
Assertions.assertThat
(AtomicBoolean actual) Create assertion forAtomicBoolean
.static AtomicIntegerAssert
Assertions.assertThat
(AtomicInteger actual) Create assertion forAtomicInteger
.static AtomicIntegerArrayAssert
Assertions.assertThat
(AtomicIntegerArray actual) Create int[] assertion forAtomicIntegerArray
.static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT>
Assertions.assertThat
(AtomicIntegerFieldUpdater<OBJECT> actual) Create assertion forAtomicIntegerFieldUpdater
.static AtomicLongAssert
Assertions.assertThat
(AtomicLong actual) Create assertion forAtomicLong
.static AtomicLongArrayAssert
Assertions.assertThat
(AtomicLongArray actual) Create assertion forAtomicLongArray
.static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT>
Assertions.assertThat
(AtomicLongFieldUpdater<OBJECT> actual) Create assertion forAtomicLongFieldUpdater
.static <VALUE> AtomicMarkableReferenceAssert<VALUE>
Assertions.assertThat
(AtomicMarkableReference<VALUE> actual) Create assertion forAtomicMarkableReference
.static <VALUE> AtomicReferenceAssert<VALUE>
Assertions.assertThat
(AtomicReference<VALUE> actual) Create assertion forAtomicReference
.static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
Assertions.assertThat
(AtomicReferenceArray<ELEMENT> actual) Create assertion forAtomicReferenceArray
.static <FIELD,
OBJECT>
AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT> Assertions.assertThat
(AtomicReferenceFieldUpdater<OBJECT, FIELD> actual) Create assertion forAtomicReferenceFieldUpdater
.static <VALUE> AtomicStampedReferenceAssert<VALUE>
Assertions.assertThat
(AtomicStampedReference<VALUE> actual) Create assertion forAtomicStampedReference
.static <RESULT> CompletableFutureAssert<RESULT>
Assertions.assertThat
(CompletableFuture<RESULT> actual) Create assertion forCompletableFuture
.static <RESULT> AbstractFutureAssert<?,
? extends Future<? extends RESULT>, RESULT> Assertions.assertThat
(Future<RESULT> actual) Create assertion forFuture
.static AbstractDateAssert<?>
Assertions.assertThat
(Date actual) Creates a new instance of
.DateAssert
static DoublePredicateAssert
Assertions.assertThat
(DoublePredicate actual) Create assertion forDoublePredicate
.static IntPredicateAssert
Assertions.assertThat
(IntPredicate actual) Create assertion forIntPredicate
.static LongPredicateAssert
Assertions.assertThat
(LongPredicate actual) Create assertion forLongPredicate
.static <T> PredicateAssert<T>
Assertions.assertThat
(Predicate<T> actual) Create assertion forPredicate
.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 forOptional
.static OptionalDoubleAssert
Assertions.assertThat
(OptionalDouble actual) Create assertion forOptionalDouble
.static OptionalIntAssert
Assertions.assertThat
(OptionalInt actual) Create assertion forOptionalInt
.static OptionalLongAssert
Assertions.assertThat
(OptionalLong actual) Create assertion forOptionalInt
.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
from the givenListAssert
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
with standard comparison semantics.GenericComparableAssert
static <T extends AssertDelegateTarget>
TAssertions.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 ofClassAssert
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 forOffsetTime
.static AbstractZonedDateTimeAssert<?>
AssertionsForClassTypes.assertThat
(ZonedDateTime actual) Creates a new instance of
.ZonedDateTimeAssert
static <RESULT> CompletableFutureAssert<RESULT>
AssertionsForClassTypes.assertThat
(CompletableFuture<RESULT> actual) Create assertion forCompletableFuture
.static AbstractDateAssert<?>
AssertionsForClassTypes.assertThat
(Date actual) Creates a new instance of
.DateAssert
static <VALUE> OptionalAssert<VALUE>
AssertionsForClassTypes.assertThat
(Optional<VALUE> actual) Create assertion forOptional
.static OptionalDoubleAssert
AssertionsForClassTypes.assertThat
(OptionalDouble actual) Create assertion forOptionalDouble
.static OptionalIntAssert
AssertionsForClassTypes.assertThat
(OptionalInt actual) Create assertion forOptionalInt
.static OptionalLongAssert
AssertionsForClassTypes.assertThat
(OptionalLong actual) Create assertion forOptionalInt
.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 ofPathAssert
static DoublePredicateAssert
AssertionsForInterfaceTypes.assertThat
(DoublePredicate actual) Create assertion forDoublePredicate
.static IntPredicateAssert
AssertionsForInterfaceTypes.assertThat
(IntPredicate actual) Create assertion forIntPredicate
.static LongPredicateAssert
AssertionsForInterfaceTypes.assertThat
(LongPredicate actual) Create assertion forLongPredicate
.static <T> PredicateAssert<T>
AssertionsForInterfaceTypes.assertThat
(Predicate<T> actual) Create assertion forPredicate
.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
from the givenListAssert
BaseStream
.static <T extends Comparable<? super T>>
AbstractComparableAssert<?,T> AssertionsForInterfaceTypes.assertThat
(T actual) Creates a new instance of
with standard comparison semantics.GenericComparableAssert
static <T extends AssertDelegateTarget>
TAssertionsForInterfaceTypes.assertThat
(T assertion) Returns the given assertion.Java6AbstractStandardSoftAssertions.assertThat
(boolean actual) Creates a new instance of
.BooleanAssert
Java6AbstractStandardSoftAssertions.assertThat
(boolean[] actual) Creates a new instance of
.BooleanArrayAssert
Java6AbstractStandardSoftAssertions.assertThat
(byte actual) Creates a new instance of
.ByteAssert
Java6AbstractStandardSoftAssertions.assertThat
(byte[] actual) Creates a new instance of
.ByteArrayAssert
Java6AbstractStandardSoftAssertions.assertThat
(char actual) Creates a new instance of
.CharacterAssert
Java6AbstractStandardSoftAssertions.assertThat
(char[] actual) Creates a new instance of
.CharArrayAssert
Java6AbstractStandardSoftAssertions.assertThat
(double actual) Creates a new instance of
.DoubleAssert
Java6AbstractStandardSoftAssertions.assertThat
(double[] actual) Creates a new instance of
.DoubleArrayAssert
Java6AbstractStandardSoftAssertions.assertThat
(float actual) Creates a new instance of
.FloatAssert
Java6AbstractStandardSoftAssertions.assertThat
(float[] actual) Creates a new instance of
.FloatArrayAssert
Java6AbstractStandardSoftAssertions.assertThat
(int actual) Creates a new instance of
.IntegerAssert
Java6AbstractStandardSoftAssertions.assertThat
(int[] actual) Creates a new instance of
.IntArrayAssert
Java6AbstractStandardSoftAssertions.assertThat
(long actual) Creates a new instance of
.LongAssert
Java6AbstractStandardSoftAssertions.assertThat
(long[] actual) Creates a new instance of
.LongArrayAssert
Java6AbstractStandardSoftAssertions.assertThat
(short actual) Creates a new instance of
.ShortAssert
Java6AbstractStandardSoftAssertions.assertThat
(short[] actual) Creates a new instance of
.ShortArrayAssert
Java6AbstractStandardSoftAssertions.assertThat
(File actual) Creates a new instance of
.FileAssert
Java6AbstractStandardSoftAssertions.assertThat
(InputStream actual) Creates a new instance of
.InputStreamAssert
Java6AbstractStandardSoftAssertions.assertThat
(Boolean actual) Creates a new instance of
.BooleanAssert
Java6AbstractStandardSoftAssertions.assertThat
(Byte actual) Creates a new instance of
.ByteAssert
Java6AbstractStandardSoftAssertions.assertThat
(Character actual) Creates a new instance of
.CharacterAssert
Java6AbstractStandardSoftAssertions.assertThat
(CharSequence actual) Creates a new instance of
.CharSequenceAssert
Java6AbstractStandardSoftAssertions.assertThat
(Class<?> actual) Creates a new instance ofClassAssert
Java6AbstractStandardSoftAssertions.assertThat
(Double actual) Creates a new instance of
.DoubleAssert
Java6AbstractStandardSoftAssertions.assertThat
(Float actual) Creates a new instance of
.FloatAssert
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
Java6AbstractStandardSoftAssertions.assertThat
(Long actual) Creates a new instance of
.LongAssert
Java6AbstractStandardSoftAssertions.assertThat
(Short actual) Creates a new instance of
.ShortAssert
Java6AbstractStandardSoftAssertions.assertThat
(String actual) Creates a new instance of
.StringAssert
Java6AbstractStandardSoftAssertions.assertThat
(Throwable actual) Creates a new instance of
.ThrowableAssert
Java6AbstractStandardSoftAssertions.assertThat
(BigDecimal actual) Creates a new instance of
.BigDecimalAssert
Java6AbstractStandardSoftAssertions.assertThat
(BigInteger actual) Creates a new instance of
.BigInteger
Java6AbstractStandardSoftAssertions.assertThat
(URI actual) Creates a new instance of
.UriAssert
Java6AbstractStandardSoftAssertions.assertThat
(URL actual) Creates a new instance of
.UrlAssert
Java6AbstractStandardSoftAssertions.assertThat
(AtomicBoolean actual) Create assertion forAtomicBoolean
.Java6AbstractStandardSoftAssertions.assertThat
(AtomicInteger actual) Create assertion forAtomicInteger
.Java6AbstractStandardSoftAssertions.assertThat
(AtomicIntegerArray actual) Create assertion forAtomicIntegerArray
.<OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT>
Java6AbstractStandardSoftAssertions.assertThat
(AtomicIntegerFieldUpdater<OBJECT> actual) Create assertion forAtomicIntegerFieldUpdater
.Java6AbstractStandardSoftAssertions.assertThat
(AtomicLong actual) Create assertion forAtomicLong
.Java6AbstractStandardSoftAssertions.assertThat
(AtomicLongArray actual) Create assertion forAtomicLongArray
.<OBJECT> AtomicLongFieldUpdaterAssert<OBJECT>
Java6AbstractStandardSoftAssertions.assertThat
(AtomicLongFieldUpdater<OBJECT> actual) Create assertion forAtomicLongFieldUpdater
.<VALUE> AtomicMarkableReferenceAssert<VALUE>
Java6AbstractStandardSoftAssertions.assertThat
(AtomicMarkableReference<VALUE> actual) Create assertion forAtomicMarkableReference
.<VALUE> AtomicReferenceAssert<VALUE>
Java6AbstractStandardSoftAssertions.assertThat
(AtomicReference<VALUE> actual) Create assertion forAtomicReference
.<ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
Java6AbstractStandardSoftAssertions.assertThat
(AtomicReferenceArray<ELEMENT> actual) Create assertion forAtomicReferenceArray
.<FIELD,
OBJECT>
AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT> Java6AbstractStandardSoftAssertions.assertThat
(AtomicReferenceFieldUpdater<OBJECT, FIELD> actual) Create assertion forAtomicReferenceFieldUpdater
.<VALUE> AtomicStampedReferenceAssert<VALUE>
Java6AbstractStandardSoftAssertions.assertThat
(AtomicStampedReference<VALUE> actual) Create assertion forAtomicStampedReference
.<RESULT> FutureAssert<RESULT>
Java6AbstractStandardSoftAssertions.assertThat
(Future<? extends RESULT> actual) Creates a new instance of
.FutureAssert
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
with standard comparison semantics.GenericComparableAssert
<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 ofClassAssert
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 forAtomicBoolean
.static AtomicIntegerAssert
Java6Assertions.assertThat
(AtomicInteger actual) Create assertion forAtomicInteger
.static AtomicIntegerArrayAssert
Java6Assertions.assertThat
(AtomicIntegerArray actual) Create int[] assertion forAtomicIntegerArray
.static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT>
Java6Assertions.assertThat
(AtomicIntegerFieldUpdater<OBJECT> actual) Create assertion forAtomicIntegerFieldUpdater
.static AtomicLongAssert
Java6Assertions.assertThat
(AtomicLong actual) Create assertion forAtomicLong
.static AtomicLongArrayAssert
Java6Assertions.assertThat
(AtomicLongArray actual) Create assertion forAtomicLongArray
.static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT>
Java6Assertions.assertThat
(AtomicLongFieldUpdater<OBJECT> actual) Create assertion forAtomicLongFieldUpdater
.static <VALUE> AtomicMarkableReferenceAssert<VALUE>
Java6Assertions.assertThat
(AtomicMarkableReference<VALUE> actual) Create assertion forAtomicMarkableReference
.static <VALUE> AtomicReferenceAssert<VALUE>
Java6Assertions.assertThat
(AtomicReference<VALUE> actual) Create assertion forAtomicReference
.static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
Java6Assertions.assertThat
(AtomicReferenceArray<ELEMENT> actual) Create assertion forAtomicReferenceArray
.static <FIELD,
OBJECT>
AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT> Java6Assertions.assertThat
(AtomicReferenceFieldUpdater<OBJECT, FIELD> actual) Create assertion forAtomicReferenceFieldUpdater
.static <VALUE> AtomicStampedReferenceAssert<VALUE>
Java6Assertions.assertThat
(AtomicStampedReference<VALUE> actual) Create assertion forAtomicStampedReference
.static <RESULT> AbstractFutureAssert<?,
? extends Future<? extends RESULT>, RESULT> Java6Assertions.assertThat
(Future<RESULT> actual) Create assertion forFuture
.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
with standard comparison semantics.GenericComparableAssert
static <T> AbstractObjectAssert<?,
T> Java6Assertions.assertThat
(T actual) Creates a new instance of
.ObjectAssert
static <T extends AssertDelegateTarget>
TJava6Assertions.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 toAssertions.assertThat(boolean)
default AbstractBooleanArrayAssert<?>
WithAssertions.assertThat
(boolean[] actual) Delegate call toAssertions.assertThat(boolean)
default AbstractByteAssert<?>
WithAssertions.assertThat
(byte actual) Delegate call toAssertions.assertThat(byte)
default AbstractByteArrayAssert<?>
WithAssertions.assertThat
(byte[] actual) Delegate call toAssertions.assertThat(byte[])
default AbstractCharacterAssert<?>
WithAssertions.assertThat
(char actual) Delegate call toAssertions.assertThat(char)
default AbstractCharArrayAssert<?>
WithAssertions.assertThat
(char[] actual) Delegate call toAssertions.assertThat(char[])
default AbstractDoubleAssert<?>
WithAssertions.assertThat
(double actual) Delegate call toAssertions.assertThat(double)
default AbstractDoubleArrayAssert<?>
WithAssertions.assertThat
(double[] actual) Delegate call toAssertions.assertThat(double[])
default AbstractFloatAssert<?>
WithAssertions.assertThat
(float actual) Delegate call toAssertions.assertThat(float)
default AbstractFloatArrayAssert<?>
WithAssertions.assertThat
(float[] actual) Delegate call toAssertions.assertThat(float[])
default AbstractIntegerAssert<?>
WithAssertions.assertThat
(int actual) Delegate call toAssertions.assertThat(int)
default AbstractIntArrayAssert<?>
WithAssertions.assertThat
(int[] actual) Delegate call toAssertions.assertThat(int[])
default AbstractLongAssert<?>
WithAssertions.assertThat
(long actual) Delegate call toAssertions.assertThat(long)
default AbstractLongArrayAssert<?>
WithAssertions.assertThat
(long[] actual) Delegate call toAssertions.assertThat(long[])
default AbstractShortAssert<?>
WithAssertions.assertThat
(short actual) Delegate call toAssertions.assertThat(short)
default AbstractShortArrayAssert<?>
WithAssertions.assertThat
(short[] actual) Delegate call toAssertions.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 toAssertions.assertThat(Iterable, Class)
default AbstractFileAssert<?>
WithAssertions.assertThat
(File actual) Delegate call toAssertions.assertThat(File)
default AbstractInputStreamAssert<?,
? extends InputStream> WithAssertions.assertThat
(InputStream actual) Delegate call toAssertions.assertThat(InputStream)
default AbstractBooleanAssert<?>
WithAssertions.assertThat
(Boolean actual) Delegate call toAssertions.assertThat(Boolean)
default AbstractByteAssert<?>
WithAssertions.assertThat
(Byte actual) Delegate call toAssertions.assertThat(Byte)
default AbstractCharacterAssert<?>
WithAssertions.assertThat
(Character actual) Delegate call toAssertions.assertThat(Character)
default AbstractCharSequenceAssert<?,
? extends CharSequence> WithAssertions.assertThat
(CharSequence actual) Delegate call toAssertions.assertThat(CharSequence)
default AbstractClassAssert<?>
WithAssertions.assertThat
(Class<?> actual) Delegate call toAssertions.assertThat(Class)
default AbstractDoubleAssert<?>
WithAssertions.assertThat
(Double actual) Delegate call toAssertions.assertThat(Double)
default AbstractFloatAssert<?>
WithAssertions.assertThat
(Float actual) Delegate call toAssertions.assertThat(Float)
default AbstractIntegerAssert<?>
WithAssertions.assertThat
(Integer actual) Delegate call toAssertions.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 toAssertions.assertThat(Iterable, AssertFactory)
default <T> IterableAssert<T>
WithAssertions.assertThat
(Iterable<? extends T> actual) Delegate call toAssertions.assertThat(Iterable)
default AbstractLongAssert<?>
WithAssertions.assertThat
(Long actual) Delegate call toAssertions.assertThat(Long)
default AbstractShortAssert<?>
WithAssertions.assertThat
(Short actual) Delegate call toAssertions.assertThat(Short)
default AbstractCharSequenceAssert<?,
String> WithAssertions.assertThat
(String actual) Delegate call toAssertions.assertThat(String)
default AbstractThrowableAssert<?,
? extends Throwable> WithAssertions.assertThat
(Throwable actual) Delegate call toAssertions.assertThat(Throwable)
default AbstractBigDecimalAssert<?>
WithAssertions.assertThat
(BigDecimal actual) Delegate call toAssertions.assertThat(BigDecimal)
default AbstractBigIntegerAssert<?>
WithAssertions.assertThat
(BigInteger actual) Creates a new instance of
.BigIntegerAssert
default AbstractPathAssert<?>
WithAssertions.assertThat
(Path actual) Delegate call toAssertions.assertThat(Path)
default <RESULT> AbstractFutureAssert<?,
? extends Future<? extends RESULT>, RESULT> WithAssertions.assertThat
(Future<RESULT> actual) Delegate call toAssertions.assertThat(Future)
default AbstractDateAssert<?>
WithAssertions.assertThat
(Date actual) Delegate call toAssertions.assertThat(Date)
default <T> IterableAssert<T>
WithAssertions.assertThat
(Iterator<? extends T> actual) Delegate call toAssertions.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 toAssertions.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 toAssertions.assertThat(List, AssertFactory)
)}default <T> ListAssert<? extends T>
WithAssertions.assertThat
(List<? extends T> actual) Delegate call toAssertions.assertThat(List)
default <K,
V> MapAssert<K, V> WithAssertions.assertThat
(Map<K, V> actual) Delegate call toAssertions.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 toAssertions.assertThat(List)
default <T extends AssertDelegateTarget>
TWithAssertions.assertThat
(T assertion) Delegate call toAssertions.assertThat(AssertDelegateTarget)
default <T> AbstractObjectAssert<?,
T> WithAssertions.assertThat
(T actual) Delegate call toAssertions.assertThat(Object)
default <T extends Comparable<? super T>>
AbstractComparableAssert<?,T> WithAssertions.assertThat
(T actual) Delegate call toAssertions.assertThat(Comparable)
default <T> AbstractObjectArrayAssert<?,
T> WithAssertions.assertThat
(T[] actual) Delegate call toAssertions.assertThat(Object[])
static AbstractThrowableAssert<?,
? extends Throwable> Assertions.assertThatCode
(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable) Allows to capture and then assert on aThrowable
more easily when used with Java 8 lambdas.static AbstractThrowableAssert<?,
? extends Throwable> AssertionsForClassTypes.assertThatCode
(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable) Allows to capture and then assert on aThrowable
more easily when used with Java 8 lambdas.AbstractThrowableAssert<?,
? extends Throwable> Java6AbstractStandardSoftAssertions.assertThatCode
(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable) Allows to capture and then assert on aThrowable
more easily when used with Java 8 lambdas.static AbstractThrowableAssert<?,
? extends Throwable> Java6Assertions.assertThatCode
(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable) Allows to capture and then assert on aThrowable
.default AbstractThrowableAssert<?,
? extends Throwable> WithAssertions.assertThatCode
(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable) Allows to capture and then assert on aThrowable
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 giventhrowingCallable
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 giventhrowingCallable
which allows to chain assertions on the thrown exception.Assertions.assertThatIllegalArgumentException()
Assertions.assertThatIllegalStateException()
Alias forAssertions.assertThatExceptionOfType(Class)
forIllegalStateException
.static ThrowableTypeAssert<IOException>
Assertions.assertThatIOException()
Alias forAssertions.assertThatExceptionOfType(Class)
forIOException
.Assertions.assertThatNullPointerException()
Alias forAssertions.assertThatExceptionOfType(Class)
forNullPointerException
.static AbstractThrowableAssert<?,
? extends Throwable> Assertions.assertThatThrownBy
(ThrowableAssert.ThrowingCallable shouldRaiseThrowable) Allows to capture and then assert on aThrowable
more easily when used with Java 8 lambdas.static AbstractThrowableAssert<?,
? extends Throwable> AssertionsForClassTypes.assertThatThrownBy
(ThrowableAssert.ThrowingCallable shouldRaiseThrowable) Allows to capture and then assert on aThrowable
.AbstractThrowableAssert<?,
? extends Throwable> Java6AbstractStandardSoftAssertions.assertThatThrownBy
(ThrowableAssert.ThrowingCallable shouldRaiseThrowable) Allows to capture and then assert on aThrowable
more easily when used with Java 8 lambdas.static AbstractThrowableAssert<?,
? extends Throwable> Java6Assertions.assertThatThrownBy
(ThrowableAssert.ThrowingCallable shouldRaiseThrowable) Allows to capture and then assert on aThrowable
more easily when used with Java 8 lambdas.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.AbstractAssert.describedAs
(String description, Object... args) Sets the description of the assertion that is going to be called after.AbstractAssert.describedAs
(Description description) Sets the description of the assertion that is going to be called after.AbstractIterableAssert.describedAs
(String description, Object... args) AbstractIterableAssert.describedAs
(Description description) AbstractListAssert.describedAs
(String description, Object... args) AbstractListAssert.describedAs
(Description description) AbstractMapAssert.describedAs
(String description, Object... args) AbstractMapAssert.describedAs
(Description description) AbstractIterableAssert.element
(int index) Navigate and allow to perform assertions on the chosen element of theIterable
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) <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.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.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.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) <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.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 givenFunction
s to extract the values from the object under test into an array, this new array becoming the object under test.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.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.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.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 toexpectedValue
, the property/field is specified bypropertyOrFieldName
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 theFilterOperator
, the property/field is specified bypropertyOrFieldName
parameter.AbstractListAssert<?,
List<? extends ELEMENT>, ELEMENT, ObjectAssert<ELEMENT>> AbstractIterableAssert.filteredOn
(Condition<? super ELEMENT> condition) Filter the iterable under test keeping only elements matching the givenCondition
.AbstractObjectArrayAssert.filteredOn
(String propertyOrFieldName, Object expectedValue) Filter the array under test keeping only elements having a property or field equal toexpectedValue
, the property/field is specified bypropertyOrFieldName
parameter.AbstractObjectArrayAssert.filteredOn
(String propertyOrFieldName, FilterOperator<?> filterOperator) Filter the array under test keeping only elements having a property or field matching the filter expressed with theFilterOperator
, the property/field is specified bypropertyOrFieldName
parameter.AbstractObjectArrayAssert.filteredOn
(Condition<? super ELEMENT> condition) Filter the array under test keeping only elements matching the givenCondition
.AtomicReferenceArrayAssert.filteredOn
(String propertyOrFieldName, Object expectedValue) Filter the array under test keeping only elements having a property or field equal toexpectedValue
, the property/field is specified bypropertyOrFieldName
parameter.AtomicReferenceArrayAssert.filteredOn
(String propertyOrFieldName, FilterOperator<?> filterOperator) Filter the array under test keeping only elements having a property or field matching the filter expressed with theFilterOperator
, the property/field is specified bypropertyOrFieldName
parameter.AtomicReferenceArrayAssert.filteredOn
(Condition<? super T> condition) Filter the array under test keeping only elements matching the givenCondition
.AbstractListAssert<?,
List<? extends ELEMENT>, ELEMENT, ObjectAssert<ELEMENT>> AbstractIterableAssert.filteredOnNull
(String propertyOrFieldName) Filter the iterable under test keeping only elements whose property or field specified bypropertyOrFieldName
is null.AbstractObjectArrayAssert.filteredOnNull
(String propertyOrFieldName) Filter the array under test keeping only elements whose property or field specified bypropertyOrFieldName
is null.AtomicReferenceArrayAssert.filteredOnNull
(String propertyOrFieldName) Filter the array under test keeping only elements whose property or field specified bypropertyOrFieldName
is null.AbstractIterableAssert.first()
Navigate and allow to perform assertions on the first element of theIterable
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 eachIterable
'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 eachIterable
's element according to the givenExtractor
s 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 eachIterable
's element according to the givenThrowingExtractor
s 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.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.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> CallflatMap
on theOptional
under test, assertions chained afterwards are performed on theOptional
resulting from the flatMap call.protected SELF
AbstractAssert.inBinary()
Use binary object representation instead of standard representation in error messages.AbstractComparableAssert.inBinary()
AbstractEnumerableAssert.inBinary()
AbstractIterableAssert.inBinary()
Enable binary representation of Iterable elements instead of standard representation in error messages.AbstractObjectArrayAssert.inBinary()
AtomicReferenceArrayAssert.inBinary()
protected SELF
AbstractAssert.inHexadecimal()
Use hexadecimal object representation instead of standard representation in error messages.AbstractCharSequenceAssert.inHexadecimal()
AbstractComparableAssert.inHexadecimal()
AbstractEnumerableAssert.inHexadecimal()
Enable hexadecimal object representation of Iterable elements instead of standard java representation in error messages.AbstractIterableAssert.inHexadecimal()
Enable hexadecimal representation of Iterable elements instead of standard representation in error messages.AbstractObjectArrayAssert.inHexadecimal()
Enable hexadecimal object representation of Iterable elements instead of standard java representation in error messages.AtomicReferenceArrayAssert.inHexadecimal()
Enable hexadecimal object representation of Iterable elements instead of standard java representation in error messages.AbstractCharacterAssert.inUnicode()
Use unicode character representation instead of standard representation in error messages.AbstractCharArrayAssert.inUnicode()
Use unicode character representation instead of standard representation in error messages.AbstractCharSequenceAssert.inUnicode()
Use unicode character representation instead of standard representation in error messages.AbstractIterableAssert.last()
Navigate and allow to perform assertions on the first element of theIterable
under test.<U> AbstractOptionalAssert<?,
U> Callmap
on theOptional
under test, assertions chained afterwards are performed on theOptional
resulting from the map call.AbstractAssert.overridingErrorMessage
(String newErrorMessage, Object... args) Overrides AssertJ default error message by the given one.AbstractIterableAssert.overridingErrorMessage
(String newErrorMessage, Object... args) AbstractListAssert.overridingErrorMessage
(String newErrorMessage, Object... args) AbstractMapAssert.overridingErrorMessage
(String newErrorMessage, Object... args) AbstractIterableAssert<IterableAssert<T>,
Iterable<? extends T>, T, ObjectAssert<T>> IterableSizeAssert.returnToIterable()
MapSizeAssert.returnToMap()
AbstractIterableAssert.size()
Returns anAssert
object that allows performing assertions on the size of theIterable
under test.AbstractMapAssert.size()
Returns anAssert
object that allows performing assertions on the size of theMap
under test.Creates a new, proxied instance of aPathAssert
Creates a new instance of
.InstantAssert
Creates a new instance of
.LocalDateAssert
AbstractBDDSoftAssertions.then
(LocalDateTime actual) Creates a new instance of
.LocalDateTimeAssert
Creates a new instance of
.LocalTimeAssert
AbstractBDDSoftAssertions.then
(OffsetDateTime actual) Creates a new instance of
.OffsetDateTimeAssert
AbstractBDDSoftAssertions.then
(OffsetTime actual) Creates a new instance of
.OffsetTimeAssert
AbstractBDDSoftAssertions.then
(ZonedDateTime actual) Creates a new instance of
.ZonedDateTimeAssert
<RESULT> CompletableFutureAssert<RESULT>
AbstractBDDSoftAssertions.then
(CompletableFuture<RESULT> actual) Create assertion forCompletableFuture
.AbstractBDDSoftAssertions.then
(DoublePredicate actual) Create assertion forDoublePredicate
.AbstractBDDSoftAssertions.then
(IntPredicate actual) Create assertion forIntPredicate
.AbstractBDDSoftAssertions.then
(LongPredicate actual) Create assertion forDoublePredicate
.<T> SoftAssertionPredicateAssert<T>
Create assertion forPredicate
.<VALUE> OptionalAssert<VALUE>
Create assertion forOptional
.AbstractBDDSoftAssertions.then
(OptionalDouble actual) Create assertion forOptionalDouble
.AbstractBDDSoftAssertions.then
(OptionalInt actual) Create assertion forOptionalInt
.AbstractBDDSoftAssertions.then
(OptionalLong actual) Create assertion forOptionalLong
.<ELEMENT,
STREAM extends BaseStream<ELEMENT, STREAM>>
ListAssert<ELEMENT>AbstractBDDSoftAssertions.then
(BaseStream<? extends ELEMENT, STREAM> actual) Creates a new instance of
from the givenListAssert
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<?>
Creates a new instance of
.FileAssert
static AbstractInputStreamAssert<?,
? extends InputStream> BDDAssertions.then
(InputStream actual) Creates a new instance of
.InputStreamAssert
static AbstractBooleanAssert<?>
Creates a new instance of
.BooleanAssert
static AbstractByteAssert<?>
Creates a new instance of
.ByteAssert
static AbstractCharacterAssert<?>
Creates a new instance of
.CharacterAssert
static AbstractCharSequenceAssert<?,
? extends CharSequence> BDDAssertions.then
(CharSequence actual) Creates a new instance of
.CharSequenceAssert
static AbstractClassAssert<?>
Creates a new instance ofClassAssert
static AbstractDoubleAssert<?>
Creates a new instance of
.DoubleAssert
static AbstractFloatAssert<?>
Creates a new instance of
.FloatAssert
static AbstractIntegerAssert<?>
Creates a new instance of
.IntegerAssert
static <T> IterableAssert<T>
Creates a new instance of
.IterableAssert
static AbstractLongAssert<?>
Creates a new instance of
.LongAssert
static AbstractShortAssert<?>
Creates a new instance of
.ShortAssert
static AbstractCharSequenceAssert<?,
String> Creates a new instance of
.StringAssert
static AbstractThrowableAssert<?,
? extends Throwable> 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<?>
Creates a new instance of
.UriAssert
static AbstractUrlAssert<?>
Creates a new instance of
.UrlAssert
static AbstractPathAssert<?>
Creates a new instance ofPathAssert
static AbstractInstantAssert<?>
Creates a new instance of
.InstantAssert
static AbstractLocalDateAssert<?>
Creates a new instance of
.LocalDateAssert
static AbstractLocalDateTimeAssert<?>
BDDAssertions.then
(LocalDateTime actual) Creates a new instance of
.LocalDateTimeAssert
static AbstractLocalTimeAssert<?>
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 forAtomicBoolean
.static AtomicIntegerAssert
BDDAssertions.then
(AtomicInteger actual) Create assertion forAtomicInteger
.static AtomicIntegerArrayAssert
BDDAssertions.then
(AtomicIntegerArray actual) Create assertion forAtomicIntegerArray
.static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT>
BDDAssertions.then
(AtomicIntegerFieldUpdater<OBJECT> actual) Create assertion forAtomicIntegerFieldUpdater
.static AtomicLongAssert
BDDAssertions.then
(AtomicLong actual) Create assertion forAtomicLong
.static AtomicLongArrayAssert
BDDAssertions.then
(AtomicLongArray actual) Create assertion forAtomicLongArray
.static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT>
BDDAssertions.then
(AtomicLongFieldUpdater<OBJECT> actual) Create assertion forAtomicLongFieldUpdater
.static <VALUE> AtomicMarkableReferenceAssert<VALUE>
BDDAssertions.then
(AtomicMarkableReference<VALUE> actual) Create assertion forAtomicMarkableReference
.static <VALUE> AtomicReferenceAssert<VALUE>
BDDAssertions.then
(AtomicReference<VALUE> actual) Create assertion forAtomicReference
.static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
BDDAssertions.then
(AtomicReferenceArray<ELEMENT> actual) Create assertion forAtomicReferenceArray
.static <FIELD,
OBJECT>
AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT> BDDAssertions.then
(AtomicReferenceFieldUpdater<OBJECT, FIELD> actual) Create assertion forAtomicReferenceFieldUpdater
.static <VALUE> AtomicStampedReferenceAssert<VALUE>
BDDAssertions.then
(AtomicStampedReference<VALUE> actual) Create assertion forAtomicStampedReference
.static <RESULT> CompletableFutureAssert<RESULT>
BDDAssertions.then
(CompletableFuture<RESULT> future) Create assertion forCompletableFuture
.static <RESULT> AbstractFutureAssert<?,
? extends Future<? extends RESULT>, RESULT> Creates a new instance ofFutureAssert
static AbstractDateAssert<?>
Creates a new instance of
.DateAssert
static DoublePredicateAssert
BDDAssertions.then
(DoublePredicate actual) Create assertion forDoublePredicate
.static IntPredicateAssert
BDDAssertions.then
(IntPredicate actual) Create assertion forIntPredicate
.static LongPredicateAssert
BDDAssertions.then
(LongPredicate actual) Create assertion forLongPredicate
.static <T> PredicateAssert<T>
Create assertion forPredicate
.static <T> IterableAssert<T>
Creates a new instance of
.IterableAssert
static <T> ListAssert<T>
Creates a new instance of
.ListAssert
static <K,
V> MapAssert<K, V> Creates a new instance of
.MapAssert
static <VALUE> OptionalAssert<VALUE>
Create assertion forOptional
.static OptionalDoubleAssert
BDDAssertions.then
(OptionalDouble optional) Create assertion forOptionalDouble
.static OptionalIntAssert
BDDAssertions.then
(OptionalInt optional) Create assertion forOptionalInt
.static OptionalLongAssert
BDDAssertions.then
(OptionalLong optional) Create assertion forOptionalLong
.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
from the givenListAssert
BaseStream
.static <T extends Comparable<? super T>>
AbstractComparableAssert<?,T> BDDAssertions.then
(T actual) Creates a new instance of
with standard comparison semantics.GenericComparableAssert
static <T> AbstractObjectAssert<?,
T> BDDAssertions.then
(T actual) Creates a new instance of
.ObjectAssert
static <T extends AssertDelegateTarget>
TBDDAssertions.then
(T assertion) Returns the given assertion.static <T> AbstractObjectArrayAssert<?,
T> BDDAssertions.then
(T[] actual) Creates a new instance of
.ObjectArrayAssert
Java6AbstractBDDSoftAssertions.then
(boolean actual) Creates a new instance of
.BooleanAssert
Java6AbstractBDDSoftAssertions.then
(boolean[] actual) Creates a new instance of
.BooleanArrayAssert
Java6AbstractBDDSoftAssertions.then
(byte actual) Creates a new instance of
.ByteAssert
Java6AbstractBDDSoftAssertions.then
(byte[] actual) Creates a new instance of
.ByteArrayAssert
Java6AbstractBDDSoftAssertions.then
(char actual) Creates a new instance of
.CharacterAssert
Java6AbstractBDDSoftAssertions.then
(char[] actual) Creates a new instance of
.CharArrayAssert
Java6AbstractBDDSoftAssertions.then
(double actual) Creates a new instance of
.DoubleAssert
Java6AbstractBDDSoftAssertions.then
(double[] actual) Creates a new instance of
.DoubleArrayAssert
Java6AbstractBDDSoftAssertions.then
(float actual) Creates a new instance of
.FloatAssert
Java6AbstractBDDSoftAssertions.then
(float[] actual) Creates a new instance of
.FloatArrayAssert
Java6AbstractBDDSoftAssertions.then
(int actual) Creates a new instance of
.IntegerAssert
Java6AbstractBDDSoftAssertions.then
(int[] actual) Creates a new instance of
.IntArrayAssert
Java6AbstractBDDSoftAssertions.then
(long actual) Creates a new instance of
.LongAssert
Java6AbstractBDDSoftAssertions.then
(long[] actual) Creates a new instance of
.LongArrayAssert
Java6AbstractBDDSoftAssertions.then
(short actual) Creates a new instance of
.ShortAssert
Java6AbstractBDDSoftAssertions.then
(short[] actual) Creates a new instance of
.ShortArrayAssert
Creates a new instance of
.FileAssert
Java6AbstractBDDSoftAssertions.then
(InputStream actual) Creates a new instance of
.InputStreamAssert
Creates a new instance of
.BooleanAssert
Creates a new instance of
.ByteAssert
Creates a new instance of
.CharacterAssert
Java6AbstractBDDSoftAssertions.then
(CharSequence actual) Creates a new instance of
.CharSequenceAssert
Creates a new instance ofClassAssert
Creates a new instance of
.DoubleAssert
Creates a new instance of
.FloatAssert
Creates a new instance of
.IntegerAssert
<T> SoftAssertionIterableAssert<T>
Creates a new instance of
.IterableAssert
Creates a new instance of
.LongAssert
Creates a new instance of
.ShortAssert
Creates a new instance of
.StringAssert
Creates a new instance of
.ThrowableAssert
Java6AbstractBDDSoftAssertions.then
(BigDecimal actual) Creates a new instance of
.BigDecimalAssert
Java6AbstractBDDSoftAssertions.then
(BigInteger actual) Creates a new instance of
.BigIntegerAssert
Creates a new instance of
.UriAssert
Creates a new instance of
.UrlAssert
Java6AbstractBDDSoftAssertions.then
(AtomicBoolean actual) Create assertion forAtomicBoolean
.Java6AbstractBDDSoftAssertions.then
(AtomicInteger actual) Create assertion forAtomicInteger
.Java6AbstractBDDSoftAssertions.then
(AtomicIntegerArray actual) Create assertion forAtomicIntegerArray
.<OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT>
Java6AbstractBDDSoftAssertions.then
(AtomicIntegerFieldUpdater<OBJECT> actual) Create assertion forAtomicIntegerFieldUpdater
.Java6AbstractBDDSoftAssertions.then
(AtomicLong actual) Create assertion forAtomicLong
.Java6AbstractBDDSoftAssertions.then
(AtomicLongArray actual) Create assertion forAtomicLongArray
.<OBJECT> AtomicLongFieldUpdaterAssert<OBJECT>
Java6AbstractBDDSoftAssertions.then
(AtomicLongFieldUpdater<OBJECT> actual) Create assertion forAtomicLongFieldUpdater
.<VALUE> AtomicMarkableReferenceAssert<VALUE>
Java6AbstractBDDSoftAssertions.then
(AtomicMarkableReference<VALUE> actual) Create assertion forAtomicMarkableReference
.<VALUE> AtomicReferenceAssert<VALUE>
Java6AbstractBDDSoftAssertions.then
(AtomicReference<VALUE> actual) Create assertion forAtomicReference
.<ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
Java6AbstractBDDSoftAssertions.then
(AtomicReferenceArray<ELEMENT> actual) Create assertion forAtomicReferenceArray
.<FIELD,
OBJECT>
AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT> Java6AbstractBDDSoftAssertions.then
(AtomicReferenceFieldUpdater<OBJECT, FIELD> actual) Create assertion forAtomicReferenceFieldUpdater
.<VALUE> AtomicStampedReferenceAssert<VALUE>
Java6AbstractBDDSoftAssertions.then
(AtomicStampedReference<VALUE> actual) Create assertion forAtomicStampedReference
.<RESULT> FutureAssert<RESULT>
Creates a new instance of
.FutureAssert
Creates a new instance of
.DateAssert
<T> SoftAssertionIterableAssert<T>
Creates a new instance of
.IterableAssert
<T> SoftAssertionListAssert<T>
Creates a new instance of
.ListAssert
<K,
V> SoftAssertionMapAssert<K, V> Creates a new instance of
.MapAssert
<T extends Comparable<? super T>>
AbstractComparableAssert<?,T> Java6AbstractBDDSoftAssertions.then
(T actual) Creates a new instance of
with standard comparison semantics.GenericComparableAssert
<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<?>
Creates a new instance of
.FileAssert
static AbstractInputStreamAssert<?,
? extends InputStream> Java6BDDAssertions.then
(InputStream actual) Creates a new instance of
.InputStreamAssert
static AbstractBooleanAssert<?>
Creates a new instance of
.BooleanAssert
static AbstractByteAssert<?>
Creates a new instance of
.ByteAssert
static AbstractCharacterAssert<?>
Creates a new instance of
.CharacterAssert
static AbstractCharSequenceAssert<?,
? extends CharSequence> Java6BDDAssertions.then
(CharSequence actual) Creates a new instance of
.CharSequenceAssert
static AbstractClassAssert<?>
Creates a new instance ofClassAssert
static AbstractDoubleAssert<?>
Creates a new instance of
.DoubleAssert
static AbstractFloatAssert<?>
Creates a new instance of
.FloatAssert
static AbstractIntegerAssert<?>
Creates a new instance of
.IntegerAssert
static <T> AbstractIterableAssert<?,
Iterable<? extends T>, T, ObjectAssert<T>> Creates a new instance of
.IterableAssert
static AbstractLongAssert<?>
Creates a new instance of
.LongAssert
static AbstractShortAssert<?>
Creates a new instance of
.ShortAssert
static AbstractCharSequenceAssert<?,
String> Creates a new instance of
.StringAssert
static AbstractThrowableAssert<?,
? extends Throwable> 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<?>
Creates a new instance of
.UriAssert
static AbstractUrlAssert<?>
Creates a new instance of
.UrlAssert
static AtomicBooleanAssert
Java6BDDAssertions.then
(AtomicBoolean actual) Create assertion forAtomicBoolean
.static AtomicIntegerAssert
Java6BDDAssertions.then
(AtomicInteger actual) Create assertion forAtomicInteger
.static AtomicIntegerArrayAssert
Java6BDDAssertions.then
(AtomicIntegerArray actual) Create int[] assertion forAtomicIntegerArray
.static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT>
Java6BDDAssertions.then
(AtomicIntegerFieldUpdater<OBJECT> actual) Create assertion forAtomicIntegerFieldUpdater
.static AtomicLongAssert
Java6BDDAssertions.then
(AtomicLong actual) Create assertion forAtomicLong
.static AtomicLongArrayAssert
Java6BDDAssertions.then
(AtomicLongArray actual) Create assertion forAtomicLongArray
.static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT>
Java6BDDAssertions.then
(AtomicLongFieldUpdater<OBJECT> actual) Create assertion forAtomicLongFieldUpdater
.static <VALUE> AtomicMarkableReferenceAssert<VALUE>
Java6BDDAssertions.then
(AtomicMarkableReference<VALUE> actual) Create assertion forAtomicMarkableReference
.static <VALUE> AtomicReferenceAssert<VALUE>
Java6BDDAssertions.then
(AtomicReference<VALUE> actual) Create assertion forAtomicReference
.static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
Java6BDDAssertions.then
(AtomicReferenceArray<ELEMENT> actual) Create assertion forAtomicReferenceArray
.static <FIELD,
OBJECT>
AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT> Java6BDDAssertions.then
(AtomicReferenceFieldUpdater<OBJECT, FIELD> actual) Create assertion forAtomicReferenceFieldUpdater
.static <VALUE> AtomicStampedReferenceAssert<VALUE>
Java6BDDAssertions.then
(AtomicStampedReference<VALUE> actual) Create assertion forAtomicStampedReference
.static <RESULT> AbstractFutureAssert<?,
? extends Future<? extends RESULT>, RESULT> Creates a new instance of
.FutureAssert
static AbstractDateAssert<?>
Creates a new instance of
.DateAssert
static <T> AbstractIterableAssert<?,
Iterable<? extends T>, T, ObjectAssert<T>> Creates a new instance of
.IterableAssert
static <T> AbstractListAssert<?,
List<? extends T>, T, ObjectAssert<T>> Creates a new instance of
.ListAssert
static <K,
V> MapAssert<K, V> Creates a new instance of
.MapAssert
static <T extends Comparable<? super T>>
AbstractComparableAssert<?,T> Java6BDDAssertions.then
(T actual) Creates a new instance of
with standard comparison semantics.GenericComparableAssert
static <T> AbstractObjectAssert<?,
T> Java6BDDAssertions.then
(T actual) Creates a new instance of
.ObjectAssert
static <T extends AssertDelegateTarget>
TJava6BDDAssertions.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 aThrowable
more easily when used with Java 8 lambdas.AbstractThrowableAssert<?,
? extends Throwable> Java6AbstractBDDSoftAssertions.thenCode
(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable) Allows to capture and then assert on aThrowable
more easily when used with Java 8 lambdas.static AbstractThrowableAssert<?,
? extends Throwable> BDDAssertions.thenThrownBy
(ThrowableAssert.ThrowingCallable shouldRaiseThrowable) Allows to capture and then assert on aThrowable
more easily when used with Java 8 lambdas.AbstractThrowableAssert<?,
? extends Throwable> Java6AbstractBDDSoftAssertions.thenThrownBy
(ThrowableAssert.ThrowingCallable shouldRaiseThrowable) Allows to capture and then assert on aThrowable
more easily when used with Java 8 lambdas.static AbstractThrowableAssert<?,
? extends Throwable> Java6BDDAssertions.thenThrownBy
(ThrowableAssert.ThrowingCallable shouldRaiseThrowable) Allows to capture and then assert on aThrowable
more easily when used with Java 8 lambdas.AbstractFileAssert.usingCharset
(String charsetName) Specifies the name of the charset to use for text-based assertions on the file's contents.AbstractFileAssert.usingCharset
(Charset charset) Specifies the charset to use for text-based assertions on the file's contents.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).AbstractPathAssert.usingCharset
(Charset charset) Specifies the charset to use for text-based assertions on the path's contents (path must be a readable file).AbstractAssert.usingComparator
(Comparator<? super ACTUAL> customComparator) Use given custom comparator instead of relying on actual type A equals method for incoming assertion checks.AbstractBigDecimalAssert.usingComparator
(Comparator<? super BigDecimal> customComparator) AbstractBigIntegerAssert.usingComparator
(Comparator<? super BigInteger> customComparator) AbstractByteAssert.usingComparator
(Comparator<? super Byte> customComparator) AbstractCharacterAssert.usingComparator
(Comparator<? super Character> customComparator) AbstractCharSequenceAssert.usingComparator
(Comparator<? super ACTUAL> customComparator) AbstractComparableAssert.usingComparator
(Comparator<? super ACTUAL> customComparator) AbstractDateAssert.usingComparator
(Comparator<? super Date> customComparator) AbstractDoubleAssert.usingComparator
(Comparator<? super Double> customComparator) AbstractFloatAssert.usingComparator
(Comparator<? super Float> customComparator) AbstractIntegerAssert.usingComparator
(Comparator<? super Integer> customComparator) AbstractIterableAssert.usingComparator
(Comparator<? super ACTUAL> customComparator) AbstractListAssert.usingComparator
(Comparator<? super ACTUAL> customComparator) AbstractLongAssert.usingComparator
(Comparator<? super Long> customComparator) AbstractMapAssert.usingComparator
(Comparator<? super ACTUAL> customComparator) AbstractShortAssert.usingComparator
(Comparator<? super Short> customComparator) AtomicIntegerAssert.usingComparator
(Comparator<? super AtomicInteger> customComparator) 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.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.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.AbstractDoubleArrayAssert.usingComparatorWithPrecision
(Double precision) Create aDouble
comparator which compares double at the given precision and pass it toAbstractDoubleArrayAssert.usingElementComparator(Comparator)
.AbstractFloatArrayAssert.usingComparatorWithPrecision
(Float precision) Create aFloat
comparator which compares floats at the given precision and pass it toAbstractFloatArrayAssert.usingElementComparator(Comparator)
.AbstractAssert.usingDefaultComparator()
Revert to standard comparison for incoming assertion checks.AbstractBigDecimalAssert.usingDefaultComparator()
AbstractBigIntegerAssert.usingDefaultComparator()
AbstractByteAssert.usingDefaultComparator()
AbstractCharacterAssert.usingDefaultComparator()
AbstractCharSequenceAssert.usingDefaultComparator()
AbstractComparableAssert.usingDefaultComparator()
AbstractDateAssert.usingDefaultComparator()
AbstractDoubleAssert.usingDefaultComparator()
AbstractFloatAssert.usingDefaultComparator()
AbstractIntegerAssert.usingDefaultComparator()
AbstractIterableAssert.usingDefaultComparator()
AbstractListAssert.usingDefaultComparator()
AbstractLongAssert.usingDefaultComparator()
AbstractMapAssert.usingDefaultComparator()
AbstractShortAssert.usingDefaultComparator()
AtomicIntegerAssert.usingDefaultComparator()
AtomicLongAssert.usingDefaultComparator()
AbstractByteArrayAssert.usingDefaultElementComparator()
Revert to standard comparison for incoming assertion group element checks.AbstractCharArrayAssert.usingDefaultElementComparator()
Revert to standard comparison for incoming assertion group element checks.AbstractDoubleArrayAssert.usingDefaultElementComparator()
Revert to standard comparison for incoming assertion group element checks.AbstractFloatArrayAssert.usingDefaultElementComparator()
Revert to standard comparison for incoming assertion group element checks.AbstractIntArrayAssert.usingDefaultElementComparator()
Revert to standard comparison for incoming assertion group element checks.AbstractIterableAssert.usingDefaultElementComparator()
Revert to standard comparison for incoming assertion group element checks.AbstractListAssert.usingDefaultElementComparator()
AbstractLongArrayAssert.usingDefaultElementComparator()
Revert to standard comparison for incoming assertion group element checks.AbstractObjectArrayAssert.usingDefaultElementComparator()
Revert to standard comparison for incoming assertion group element checks.AbstractShortArrayAssert.usingDefaultElementComparator()
Revert to standard comparison for incoming assertion group element checks.AtomicIntegerArrayAssert.usingDefaultElementComparator()
Revert to standard comparison for incoming assertion group element checks.AtomicReferenceArrayAssert.usingDefaultElementComparator()
Revert to standard comparison for incoming assertion group element checks.AbstractOptionalAssert.usingDefaultValueComparator()
Revert to standard comparison for incoming assertionOptional
value checks.AbstractByteArrayAssert.usingElementComparator
(Comparator<? super Byte> customComparator) Use given custom comparator instead of relying on actual type Aequals
method to compare group elements for incoming assertion checks.AbstractCharArrayAssert.usingElementComparator
(Comparator<? super Character> customComparator) Use given custom comparator instead of relying on actual type Aequals
method to compare group elements for incoming assertion checks.AbstractDoubleArrayAssert.usingElementComparator
(Comparator<? super Double> customComparator) Use given custom comparator instead of relying on actual type Aequals
method to compare group elements for incoming assertion checks.AbstractFloatArrayAssert.usingElementComparator
(Comparator<? super Float> customComparator) Use given custom comparator instead of relying on actual type Aequals
method to compare group elements for incoming assertion checks.AbstractIntArrayAssert.usingElementComparator
(Comparator<? super Integer> customComparator) Use given custom comparator instead of relying on actual type Aequals
method to compare group elements for incoming assertion checks.AbstractIterableAssert.usingElementComparator
(Comparator<? super ELEMENT> elementComparator) Use given custom comparator instead of relying on actual type Aequals
method to compare group elements for incoming assertion checks.AbstractListAssert.usingElementComparator
(Comparator<? super ELEMENT> customComparator) AbstractLongArrayAssert.usingElementComparator
(Comparator<? super Long> customComparator) Use given custom comparator instead of relying on actual type Aequals
method to compare group elements for incoming assertion checks.AbstractObjectArrayAssert.usingElementComparator
(Comparator<? super ELEMENT> elementComparator) Use given custom comparator instead of relying on actual type Aequals
method to compare group elements for incoming assertion checks.AbstractShortArrayAssert.usingElementComparator
(Comparator<? super Short> customComparator) Use given custom comparator instead of relying on actual type Aequals
method to compare group elements for incoming assertion checks.AtomicIntegerArrayAssert.usingElementComparator
(Comparator<? super Integer> customComparator) Use given custom comparator instead of relying on Integerequals
method to compare elements for incoming assertion checks.AtomicLongArrayAssert.usingElementComparator
(Comparator<? super Long> customComparator) Use given custom comparator instead of relying on Longequals
method to compare elements for incoming assertion checks.AtomicReferenceArrayAssert.usingElementComparator
(Comparator<? super T> elementComparator) Use given custom comparator instead of relying on actual element typeequals
method to compare AtomicReferenceArray elements for incoming assertion checks.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 Aequals
method to compare group elements for incoming assertion checks.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 Aequals
method to compare group elements for incoming assertion checks.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 Aequals
method to compare AtomicReferenceArray elements for incoming assertion checks.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 Aequals
method to compare group elements for incoming assertion checks.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 Aequals
method to compare group elements for incoming assertion checks.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 Aequals
method to compare AtomicReferenceArray elements for incoming assertion checks.AbstractIterableAssert.usingFieldByFieldElementComparator()
Use field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type Aequals
method to compare group elements for incoming assertion checks.AbstractObjectArrayAssert.usingFieldByFieldElementComparator()
Use field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type Aequals
method to compare group elements for incoming assertion checks.AtomicReferenceArrayAssert.usingFieldByFieldElementComparator()
Use field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type Aequals
method to compare AtomicReferenceArray elements for incoming assertion checks.AbstractOptionalAssert.usingFieldByFieldValueComparator()
Use field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type Aequals
method to compare theOptional
value's object for incoming assertion checks.AbstractIterableAssert.usingRecursiveFieldByFieldElementComparator()
Use a recursive field/property by field/property comparison (including inherited fields/properties) instead of relying on actual typeequals
method to compare group elements for incoming assertion checks.AbstractObjectArrayAssert.usingRecursiveFieldByFieldElementComparator()
Use a recursive field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type Aequals
method to compare group elements for incoming assertion checks.AtomicReferenceArrayAssert.usingRecursiveFieldByFieldElementComparator()
Use a recursive field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type Aequals
method to compare AtomicReferenceArray elements for incoming assertion checks.AbstractOptionalAssert.usingValueComparator
(Comparator<? super VALUE> customComparator) Use given custom comparator instead of relying on actual type Aequals
method to compare theOptional
value's object for incoming assertion checks.AbstractDateAssert.withDateFormat
(String userCustomDateFormatPattern) Instead of using default date formats for the date String based Date assertions likeAbstractDateAssert.isEqualTo(String)
, AssertJ is gonna use any date formats registered with one of these methods : this methodAbstractDateAssert.withDateFormat(java.text.DateFormat)
AbstractDateAssert.registerCustomDateFormat(java.text.DateFormat)
AbstractDateAssert.registerCustomDateFormat(String)
AbstractDateAssert.withDateFormat
(DateFormat userCustomDateFormat) Instead of using default date formats for the date String based Date assertions likeAbstractDateAssert.isEqualTo(String)
, AssertJ is gonna use any date formats registered with one of these methods :AbstractDateAssert.withDateFormat(String)
this methodAbstractDateAssert.registerCustomDateFormat(java.text.DateFormat)
AbstractDateAssert.registerCustomDateFormat(String)
AbstractDateAssert.withDefaultDateFormatsOnly()
Remove all registered custom date formats => use only the defaults date formats to parse string as date.AbstractAssert.withFailMessage
(String newErrorMessage, Object... args) Alternative method forAbstractAssert.overridingErrorMessage(java.lang.String, java.lang.Object...)
AbstractIterableAssert.withFailMessage
(String newErrorMessage, Object... args) AbstractListAssert.withFailMessage
(String newErrorMessage, Object... args) AbstractMapAssert.withFailMessage
(String newErrorMessage, Object... args) AbstractAssert.withRepresentation
(Representation representation) Use the givenRepresentation
to describe/represent values in AssertJ error messages.AbstractAssert.withThreadDumpOnError()
In case of an assertion error, a thread dump will be printed toSystem.err
.AbstractIterableAssert.withThreadDumpOnError()
AbstractListAssert.withThreadDumpOnError()
AbstractMapAssert.withThreadDumpOnError()