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