Package | Description |
---|---|
org.assertj.core.api |
Modifier and Type | Class and Description |
---|---|
class |
Assertions
Entry point for assertion methods for different types.
|
Modifier and Type | Method and Description |
---|---|
AtomicReferenceArrayAssert<T> |
AtomicReferenceArrayAssert.as(Description description) |
SELF |
AbstractIterableAssert.as(Description description) |
SELF |
AbstractObjectAssert.as(Description description) |
SELF |
AbstractAssert.as(Description description)
Sets the description of the assertion that is going to be called after.
|
SELF |
AbstractListAssert.as(Description description) |
SELF |
AbstractMapAssert.as(Description description) |
ThrowableTypeAssert<T> |
ThrowableTypeAssert.as(Description description)
Sets the description of the assertion that is going to be called after.
|
AtomicReferenceArrayAssert<T> |
AtomicReferenceArrayAssert.as(String description,
Object... args) |
SELF |
AbstractIterableAssert.as(String description,
Object... args) |
SELF |
AbstractObjectAssert.as(String description,
Object... args) |
SELF |
AbstractAssert.as(String description,
Object... args)
Sets the description of the assertion that is going to be called after.
|
SELF |
AbstractListAssert.as(String description,
Object... args) |
SELF |
AbstractMapAssert.as(String description,
Object... args) |
ThrowableTypeAssert<T> |
ThrowableTypeAssert.as(String description,
Object... args)
Sets the description of the assertion that is going to be called after.
|
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.
|
default <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
WithAssertions.assertThat(ACTUAL actual,
Class<ELEMENT_ASSERT> assertClass)
Creates a new instance of
allowing to navigate to any Iterable element
in order to perform assertions on it. |
static <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
Assertions.assertThat(ACTUAL actual,
Class<ELEMENT_ASSERT> assertClass)
Creates a new instance of
allowing to navigate to any Iterable element
in order to perform assertions on it. |
AtomicBooleanAssert |
Java6AbstractStandardSoftAssertions.assertThat(AtomicBoolean actual)
Create assertion for
AtomicBoolean . |
static AtomicBooleanAssert |
Assertions.assertThat(AtomicBoolean actual)
Create assertion for
AtomicBoolean . |
static AtomicBooleanAssert |
Java6Assertions.assertThat(AtomicBoolean actual)
Create assertion for
AtomicBoolean . |
AtomicIntegerAssert |
Java6AbstractStandardSoftAssertions.assertThat(AtomicInteger actual)
Create assertion for
AtomicInteger . |
static AtomicIntegerAssert |
Assertions.assertThat(AtomicInteger actual)
Create assertion for
AtomicInteger . |
static AtomicIntegerAssert |
Java6Assertions.assertThat(AtomicInteger actual)
Create assertion for
AtomicInteger . |
AtomicIntegerArrayAssert |
Java6AbstractStandardSoftAssertions.assertThat(AtomicIntegerArray actual)
Create assertion for
AtomicIntegerArray . |
static AtomicIntegerArrayAssert |
Assertions.assertThat(AtomicIntegerArray actual)
Create int[] assertion for
AtomicIntegerArray . |
static AtomicIntegerArrayAssert |
Java6Assertions.assertThat(AtomicIntegerArray actual)
Create int[] assertion for
AtomicIntegerArray . |
<OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT> |
Java6AbstractStandardSoftAssertions.assertThat(AtomicIntegerFieldUpdater<OBJECT> actual)
Create assertion for
AtomicIntegerFieldUpdater . |
static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT> |
Assertions.assertThat(AtomicIntegerFieldUpdater<OBJECT> actual)
Create assertion for
AtomicIntegerFieldUpdater . |
static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT> |
Java6Assertions.assertThat(AtomicIntegerFieldUpdater<OBJECT> actual)
Create assertion for
AtomicIntegerFieldUpdater . |
AtomicLongAssert |
Java6AbstractStandardSoftAssertions.assertThat(AtomicLong actual)
Create assertion for
AtomicLong . |
static AtomicLongAssert |
Assertions.assertThat(AtomicLong actual)
Create assertion for
AtomicLong . |
static AtomicLongAssert |
Java6Assertions.assertThat(AtomicLong actual)
Create assertion for
AtomicLong . |
AtomicLongArrayAssert |
Java6AbstractStandardSoftAssertions.assertThat(AtomicLongArray actual)
Create assertion for
AtomicLongArray . |
static AtomicLongArrayAssert |
Assertions.assertThat(AtomicLongArray actual)
Create assertion for
AtomicLongArray . |
static AtomicLongArrayAssert |
Java6Assertions.assertThat(AtomicLongArray actual)
Create assertion for
AtomicLongArray . |
<OBJECT> AtomicLongFieldUpdaterAssert<OBJECT> |
Java6AbstractStandardSoftAssertions.assertThat(AtomicLongFieldUpdater<OBJECT> actual)
Create assertion for
AtomicLongFieldUpdater . |
static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT> |
Assertions.assertThat(AtomicLongFieldUpdater<OBJECT> actual)
Create assertion for
AtomicLongFieldUpdater . |
static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT> |
Java6Assertions.assertThat(AtomicLongFieldUpdater<OBJECT> actual)
Create assertion for
AtomicLongFieldUpdater . |
<VALUE> AtomicMarkableReferenceAssert<VALUE> |
Java6AbstractStandardSoftAssertions.assertThat(AtomicMarkableReference<VALUE> actual)
Create assertion for
AtomicMarkableReference . |
static <VALUE> AtomicMarkableReferenceAssert<VALUE> |
Assertions.assertThat(AtomicMarkableReference<VALUE> actual)
Create assertion for
AtomicMarkableReference . |
static <VALUE> AtomicMarkableReferenceAssert<VALUE> |
Java6Assertions.assertThat(AtomicMarkableReference<VALUE> actual)
Create assertion for
AtomicMarkableReference . |
<VALUE> AtomicReferenceAssert<VALUE> |
Java6AbstractStandardSoftAssertions.assertThat(AtomicReference<VALUE> actual)
Create assertion for
AtomicReference . |
static <VALUE> AtomicReferenceAssert<VALUE> |
Assertions.assertThat(AtomicReference<VALUE> actual)
Create assertion for
AtomicReference . |
static <VALUE> AtomicReferenceAssert<VALUE> |
Java6Assertions.assertThat(AtomicReference<VALUE> actual)
Create assertion for
AtomicReference . |
<ELEMENT> AtomicReferenceArrayAssert<ELEMENT> |
Java6AbstractStandardSoftAssertions.assertThat(AtomicReferenceArray<ELEMENT> actual)
Create assertion for
AtomicReferenceArray . |
static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT> |
Assertions.assertThat(AtomicReferenceArray<ELEMENT> actual)
Create assertion for
AtomicReferenceArray . |
static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT> |
Java6Assertions.assertThat(AtomicReferenceArray<ELEMENT> actual)
Create assertion for
AtomicReferenceArray . |
<FIELD,OBJECT> |
Java6AbstractStandardSoftAssertions.assertThat(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)
Create assertion for
AtomicReferenceFieldUpdater . |
static <FIELD,OBJECT> |
Assertions.assertThat(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)
Create assertion for
AtomicReferenceFieldUpdater . |
static <FIELD,OBJECT> |
Java6Assertions.assertThat(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)
Create assertion for
AtomicReferenceFieldUpdater . |
<VALUE> AtomicStampedReferenceAssert<VALUE> |
Java6AbstractStandardSoftAssertions.assertThat(AtomicStampedReference<VALUE> actual)
Create assertion for
AtomicStampedReference . |
static <VALUE> AtomicStampedReferenceAssert<VALUE> |
Assertions.assertThat(AtomicStampedReference<VALUE> actual)
Create assertion for
AtomicStampedReference . |
static <VALUE> AtomicStampedReferenceAssert<VALUE> |
Java6Assertions.assertThat(AtomicStampedReference<VALUE> actual)
Create assertion for
AtomicStampedReference . |
BigDecimalAssert |
Java6AbstractStandardSoftAssertions.assertThat(BigDecimal actual)
Creates a new instance of
. |
default AbstractBigDecimalAssert<?> |
WithAssertions.assertThat(BigDecimal actual)
Creates a new instance of
. |
static AbstractBigDecimalAssert<?> |
Assertions.assertThat(BigDecimal actual)
Creates a new instance of
. |
static AbstractBigDecimalAssert<?> |
AssertionsForClassTypes.assertThat(BigDecimal actual)
Creates a new instance of
. |
static AbstractBigDecimalAssert<?> |
Java6Assertions.assertThat(BigDecimal actual)
Creates a new instance of
. |
BigIntegerAssert |
Java6AbstractStandardSoftAssertions.assertThat(BigInteger actual)
Creates a new instance of
. |
default AbstractBigIntegerAssert<?> |
WithAssertions.assertThat(BigInteger actual)
Creates a new instance of
. |
static AbstractBigIntegerAssert<?> |
Assertions.assertThat(BigInteger actual)
Creates a new instance of
. |
static AbstractBigIntegerAssert<?> |
Java6Assertions.assertThat(BigInteger actual)
Creates a new instance of
. |
BooleanAssert |
Java6AbstractStandardSoftAssertions.assertThat(boolean actual)
Creates a new instance of
. |
default AbstractBooleanAssert<?> |
WithAssertions.assertThat(boolean actual)
Creates a new instance of
. |
static AbstractBooleanAssert<?> |
Assertions.assertThat(boolean actual)
Creates a new instance of
. |
static AbstractBooleanAssert<?> |
AssertionsForClassTypes.assertThat(boolean actual)
Creates a new instance of
. |
static AbstractBooleanAssert<?> |
Java6Assertions.assertThat(boolean actual)
Creates a new instance of
. |
BooleanAssert |
Java6AbstractStandardSoftAssertions.assertThat(Boolean actual)
Creates a new instance of
. |
default AbstractBooleanAssert<?> |
WithAssertions.assertThat(Boolean actual)
Creates a new instance of
. |
static AbstractBooleanAssert<?> |
Assertions.assertThat(Boolean actual)
Creates a new instance of
. |
static AbstractBooleanAssert<?> |
AssertionsForClassTypes.assertThat(Boolean actual)
Creates a new instance of
. |
static AbstractBooleanAssert<?> |
Java6Assertions.assertThat(Boolean actual)
Creates a new instance of
. |
BooleanArrayAssert |
Java6AbstractStandardSoftAssertions.assertThat(boolean[] actual)
Creates a new instance of
. |
default AbstractBooleanArrayAssert<?> |
WithAssertions.assertThat(boolean[] actual)
Creates a new instance of
. |
static AbstractBooleanArrayAssert<?> |
Assertions.assertThat(boolean[] actual)
Creates a new instance of
. |
static AbstractBooleanArrayAssert<?> |
AssertionsForClassTypes.assertThat(boolean[] actual)
Creates a new instance of
. |
static AbstractBooleanArrayAssert<?> |
Java6Assertions.assertThat(boolean[] actual)
Creates a new instance of
. |
ByteAssert |
Java6AbstractStandardSoftAssertions.assertThat(byte actual)
Creates a new instance of
. |
default AbstractByteAssert<?> |
WithAssertions.assertThat(byte actual)
Creates a new instance of
. |
static AbstractByteAssert<?> |
Assertions.assertThat(byte actual)
Creates a new instance of
. |
static AbstractByteAssert<?> |
AssertionsForClassTypes.assertThat(byte actual)
Creates a new instance of
. |
static AbstractByteAssert<?> |
Java6Assertions.assertThat(byte actual)
Creates a new instance of
. |
ByteAssert |
Java6AbstractStandardSoftAssertions.assertThat(Byte actual)
Creates a new instance of
. |
default AbstractByteAssert<?> |
WithAssertions.assertThat(Byte actual)
Creates a new instance of
. |
static AbstractByteAssert<?> |
Assertions.assertThat(Byte actual)
Creates a new instance of
. |
static AbstractByteAssert<?> |
AssertionsForClassTypes.assertThat(Byte actual)
Creates a new instance of
. |
static AbstractByteAssert<?> |
Java6Assertions.assertThat(Byte actual)
Creates a new instance of
. |
ByteArrayAssert |
Java6AbstractStandardSoftAssertions.assertThat(byte[] actual)
Creates a new instance of
. |
default AbstractByteArrayAssert<?> |
WithAssertions.assertThat(byte[] actual)
Creates a new instance of
. |
static AbstractByteArrayAssert<?> |
Assertions.assertThat(byte[] actual)
Creates a new instance of
. |
static AbstractByteArrayAssert<?> |
AssertionsForClassTypes.assertThat(byte[] actual)
Creates a new instance of
. |
static AbstractByteArrayAssert<?> |
Java6Assertions.assertThat(byte[] actual)
Creates a new instance of
. |
CharacterAssert |
Java6AbstractStandardSoftAssertions.assertThat(char actual)
Creates a new instance of
. |
default AbstractCharacterAssert<?> |
WithAssertions.assertThat(char actual)
Creates a new instance of
. |
static AbstractCharacterAssert<?> |
Assertions.assertThat(char actual)
Creates a new instance of
. |
static AbstractCharacterAssert<?> |
AssertionsForClassTypes.assertThat(char actual)
Creates a new instance of
. |
static AbstractCharacterAssert<?> |
Java6Assertions.assertThat(char actual)
Creates a new instance of
. |
CharArrayAssert |
Java6AbstractStandardSoftAssertions.assertThat(char[] actual)
Creates a new instance of
. |
default AbstractCharArrayAssert<?> |
WithAssertions.assertThat(char[] actual)
Creates a new instance of
. |
static AbstractCharArrayAssert<?> |
Assertions.assertThat(char[] actual)
Creates a new instance of
. |
static AbstractCharArrayAssert<?> |
AssertionsForClassTypes.assertThat(char[] actual)
Creates a new instance of
. |
static AbstractCharArrayAssert<?> |
Java6Assertions.assertThat(char[] actual)
Creates a new instance of
. |
CharacterAssert |
Java6AbstractStandardSoftAssertions.assertThat(Character actual)
Creates a new instance of
. |
default AbstractCharacterAssert<?> |
WithAssertions.assertThat(Character actual)
Creates a new instance of
. |
static AbstractCharacterAssert<?> |
Assertions.assertThat(Character actual)
Creates a new instance of
. |
static AbstractCharacterAssert<?> |
AssertionsForClassTypes.assertThat(Character actual)
Creates a new instance of
. |
static AbstractCharacterAssert<?> |
Java6Assertions.assertThat(Character actual)
Creates a new instance of
. |
CharSequenceAssert |
Java6AbstractStandardSoftAssertions.assertThat(CharSequence actual)
Creates a new instance of
. |
default AbstractCharSequenceAssert<?,? extends CharSequence> |
WithAssertions.assertThat(CharSequence actual)
Creates a new instance of
. |
static AbstractCharSequenceAssert<?,? extends CharSequence> |
AssertionsForInterfaceTypes.assertThat(CharSequence actual)
Creates a new instance of
. |
static AbstractCharSequenceAssert<?,? extends CharSequence> |
Assertions.assertThat(CharSequence actual)
Creates a new instance of
. |
static AbstractCharSequenceAssert<?,? extends CharSequence> |
Java6Assertions.assertThat(CharSequence actual)
Creates a new instance of
. |
SoftAssertionClassAssert |
Java6AbstractStandardSoftAssertions.assertThat(Class<?> actual)
Creates a new instance of
|
default AbstractClassAssert<?> |
WithAssertions.assertThat(Class<?> actual)
Creates a new instance of
|
static AbstractClassAssert<?> |
Assertions.assertThat(Class<?> actual)
Creates a new instance of
|
static AbstractClassAssert<?> |
AssertionsForClassTypes.assertThat(Class<?> actual)
Creates a new instance of
|
static AbstractClassAssert<?> |
Java6Assertions.assertThat(Class<?> actual)
Creates a new instance of
|
static <RESULT> CompletableFutureAssert<RESULT> |
Assertions.assertThat(CompletableFuture<RESULT> actual)
Create assertion for
CompletableFuture . |
<RESULT> CompletableFutureAssert<RESULT> |
AbstractStandardSoftAssertions.assertThat(CompletableFuture<RESULT> actual)
Create assertion for
CompletableFuture . |
static <RESULT> CompletableFutureAssert<RESULT> |
AssertionsForClassTypes.assertThat(CompletableFuture<RESULT> actual)
Create assertion for
CompletableFuture . |
static <RESULT> CompletableFutureAssert<RESULT> |
Assertions.assertThat(CompletionStage<RESULT> actual)
Create assertion for
CompletionStage by converting it to a CompletableFuture and returning a CompletableFutureAssert . |
<RESULT> CompletableFutureAssert<RESULT> |
AbstractStandardSoftAssertions.assertThat(CompletionStage<RESULT> actual)
Create assertion for
CompletionStage by converting it to a CompletableFuture and returning a CompletableFutureAssert . |
static <RESULT> CompletableFutureAssert<RESULT> |
AssertionsForClassTypes.assertThat(CompletionStage<RESULT> actual)
Create assertion for
CompletionStage by converting it to a CompletableFuture and returning a CompletableFutureAssert . |
DateAssert |
Java6AbstractStandardSoftAssertions.assertThat(Date actual)
Creates a new instance of
. |
default AbstractDateAssert<?> |
WithAssertions.assertThat(Date actual)
Creates a new instance of
. |
static AbstractDateAssert<?> |
Assertions.assertThat(Date actual)
Creates a new instance of
. |
static AbstractDateAssert<?> |
AssertionsForClassTypes.assertThat(Date actual)
Creates a new instance of
. |
static AbstractDateAssert<?> |
Java6Assertions.assertThat(Date actual)
Creates a new instance of
. |
DoubleAssert |
Java6AbstractStandardSoftAssertions.assertThat(double actual)
Creates a new instance of
. |
default AbstractDoubleAssert<?> |
WithAssertions.assertThat(double actual)
Creates a new instance of
. |
static AbstractDoubleAssert<?> |
Assertions.assertThat(double actual)
Creates a new instance of
. |
static AbstractDoubleAssert<?> |
AssertionsForClassTypes.assertThat(double actual)
Creates a new instance of
. |
static AbstractDoubleAssert<?> |
Java6Assertions.assertThat(double actual)
Creates a new instance of
. |
DoubleAssert |
Java6AbstractStandardSoftAssertions.assertThat(Double actual)
Creates a new instance of
. |
default AbstractDoubleAssert<?> |
WithAssertions.assertThat(Double actual)
Creates a new instance of
. |
static AbstractDoubleAssert<?> |
Assertions.assertThat(Double actual)
Creates a new instance of
. |
static AbstractDoubleAssert<?> |
AssertionsForClassTypes.assertThat(Double actual)
Creates a new instance of
. |
static AbstractDoubleAssert<?> |
Java6Assertions.assertThat(Double actual)
Creates a new instance of
. |
DoubleArrayAssert |
Java6AbstractStandardSoftAssertions.assertThat(double[] actual)
Creates a new instance of
. |
default AbstractDoubleArrayAssert<?> |
WithAssertions.assertThat(double[] actual)
Creates a new instance of
. |
static AbstractDoubleArrayAssert<?> |
Assertions.assertThat(double[] actual)
Creates a new instance of
. |
static AbstractDoubleArrayAssert<?> |
AssertionsForClassTypes.assertThat(double[] actual)
Creates a new instance of
. |
static AbstractDoubleArrayAssert<?> |
Java6Assertions.assertThat(double[] actual)
Creates a new instance of
. |
static DoublePredicateAssert |
AssertionsForInterfaceTypes.assertThat(DoublePredicate actual)
Create assertion for
DoublePredicate . |
static DoublePredicateAssert |
Assertions.assertThat(DoublePredicate actual)
Create assertion for
DoublePredicate . |
DoublePredicateAssert |
AbstractStandardSoftAssertions.assertThat(DoublePredicate actual)
Create assertion for
DoublePredicate . |
default AbstractListAssert<?,List<? extends Double>,Double,ObjectAssert<Double>> |
WithAssertions.assertThat(DoubleStream actual)
Creates a new instance of
from the given DoubleStream . |
static AbstractListAssert<?,List<? extends Double>,Double,ObjectAssert<Double>> |
AssertionsForInterfaceTypes.assertThat(DoubleStream actual)
Creates a new instance of
from the given DoubleStream . |
static AbstractListAssert<?,List<? extends Double>,Double,ObjectAssert<Double>> |
Assertions.assertThat(DoubleStream actual)
Creates a new instance of
from the given DoubleStream . |
AbstractListAssert<?,List<? extends Double>,Double,ObjectAssert<Double>> |
AbstractStandardSoftAssertions.assertThat(DoubleStream actual)
Creates a new instance of
from the given DoubleStream . |
FileAssert |
Java6AbstractStandardSoftAssertions.assertThat(File actual)
Creates a new instance of
. |
default AbstractFileAssert<?> |
WithAssertions.assertThat(File actual)
Creates a new instance of
. |
static AbstractFileAssert<?> |
Assertions.assertThat(File actual)
Creates a new instance of
. |
static AbstractFileAssert<?> |
AssertionsForClassTypes.assertThat(File actual)
Creates a new instance of
. |
static AbstractFileAssert<?> |
Java6Assertions.assertThat(File actual)
Creates a new instance of
. |
FloatAssert |
Java6AbstractStandardSoftAssertions.assertThat(float actual)
Creates a new instance of
. |
default AbstractFloatAssert<?> |
WithAssertions.assertThat(float actual)
Creates a new instance of
. |
static AbstractFloatAssert<?> |
Assertions.assertThat(float actual)
Creates a new instance of
. |
static AbstractFloatAssert<?> |
AssertionsForClassTypes.assertThat(float actual)
Creates a new instance of
. |
static AbstractFloatAssert<?> |
Java6Assertions.assertThat(float actual)
Creates a new instance of
. |
FloatAssert |
Java6AbstractStandardSoftAssertions.assertThat(Float actual)
Creates a new instance of
. |
default AbstractFloatAssert<?> |
WithAssertions.assertThat(Float actual)
Creates a new instance of
. |
static AbstractFloatAssert<?> |
Assertions.assertThat(Float actual)
Creates a new instance of
. |
static AbstractFloatAssert<?> |
AssertionsForClassTypes.assertThat(Float actual)
Creates a new instance of
. |
static AbstractFloatAssert<?> |
Java6Assertions.assertThat(Float actual)
Creates a new instance of
. |
FloatArrayAssert |
Java6AbstractStandardSoftAssertions.assertThat(float[] actual)
Creates a new instance of
. |
default AbstractFloatArrayAssert<?> |
WithAssertions.assertThat(float[] actual)
Creates a new instance of
. |
static AbstractFloatArrayAssert<?> |
Assertions.assertThat(float[] actual)
Creates a new instance of
. |
static AbstractFloatArrayAssert<?> |
AssertionsForClassTypes.assertThat(float[] actual)
Creates a new instance of
. |
static AbstractFloatArrayAssert<?> |
Java6Assertions.assertThat(float[] actual)
Creates a new instance of
. |
<RESULT> FutureAssert<RESULT> |
Java6AbstractStandardSoftAssertions.assertThat(Future<RESULT> actual)
Creates a new instance of
. |
default <RESULT> FutureAssert<RESULT> |
WithAssertions.assertThat(Future<RESULT> actual)
Create assertion for
Future . |
static <RESULT> FutureAssert<RESULT> |
Assertions.assertThat(Future<RESULT> actual)
Create assertion for
Future . |
static <RESULT> AbstractFutureAssert<?,? extends Future<? extends RESULT>,RESULT> |
Java6Assertions.assertThat(Future<RESULT> actual)
Create assertion for
Future . |
InputStreamAssert |
Java6AbstractStandardSoftAssertions.assertThat(InputStream actual)
Creates a new instance of
. |
default AbstractInputStreamAssert<?,? extends InputStream> |
WithAssertions.assertThat(InputStream actual)
Creates a new instance of
. |
static AbstractInputStreamAssert<?,? extends InputStream> |
Assertions.assertThat(InputStream actual)
Creates a new instance of
. |
static AbstractInputStreamAssert<?,? extends InputStream> |
AssertionsForClassTypes.assertThat(InputStream actual)
Creates a new instance of
. |
static AbstractInputStreamAssert<?,? extends InputStream> |
Java6Assertions.assertThat(InputStream actual)
Creates a new instance of
. |
static AbstractInstantAssert<?> |
Assertions.assertThat(Instant actual)
Creates a new instance of
. |
InstantAssert |
AbstractStandardSoftAssertions.assertThat(Instant actual)
Creates a new instance of
. |
static AbstractInstantAssert<?> |
AssertionsForClassTypes.assertThat(Instant instant)
Creates a new instance of
. |
IntegerAssert |
Java6AbstractStandardSoftAssertions.assertThat(int actual)
Creates a new instance of
. |
default AbstractIntegerAssert<?> |
WithAssertions.assertThat(int actual)
Creates a new instance of
. |
static AbstractIntegerAssert<?> |
Assertions.assertThat(int actual)
Creates a new instance of
. |
static AbstractIntegerAssert<?> |
AssertionsForClassTypes.assertThat(int actual)
Creates a new instance of
. |
static AbstractIntegerAssert<?> |
Java6Assertions.assertThat(int actual)
Creates a new instance of
. |
IntArrayAssert |
Java6AbstractStandardSoftAssertions.assertThat(int[] actual)
Creates a new instance of
. |
default AbstractIntArrayAssert<?> |
WithAssertions.assertThat(int[] actual)
Creates a new instance of
. |
static AbstractIntArrayAssert<?> |
Assertions.assertThat(int[] actual)
Creates a new instance of
. |
static AbstractIntArrayAssert<?> |
AssertionsForClassTypes.assertThat(int[] actual)
Creates a new instance of
. |
static AbstractIntArrayAssert<?> |
Java6Assertions.assertThat(int[] actual)
Creates a new instance of
. |
IntegerAssert |
Java6AbstractStandardSoftAssertions.assertThat(Integer actual)
Creates a new instance of
. |
default AbstractIntegerAssert<?> |
WithAssertions.assertThat(Integer actual)
Creates a new instance of
. |
static AbstractIntegerAssert<?> |
Assertions.assertThat(Integer actual)
Creates a new instance of
. |
static AbstractIntegerAssert<?> |
AssertionsForClassTypes.assertThat(Integer actual)
Creates a new instance of
. |
static AbstractIntegerAssert<?> |
Java6Assertions.assertThat(Integer actual)
Creates a new instance of
. |
static IntPredicateAssert |
AssertionsForInterfaceTypes.assertThat(IntPredicate actual)
Create assertion for
IntPredicate . |
static IntPredicateAssert |
Assertions.assertThat(IntPredicate actual)
Create assertion for
IntPredicate . |
IntPredicateAssert |
AbstractStandardSoftAssertions.assertThat(IntPredicate actual)
Create assertion for
IntPredicate . |
default AbstractListAssert<?,List<? extends Integer>,Integer,ObjectAssert<Integer>> |
WithAssertions.assertThat(IntStream actual)
Creates a new instance of
from the given IntStream . |
static AbstractListAssert<?,List<? extends Integer>,Integer,ObjectAssert<Integer>> |
AssertionsForInterfaceTypes.assertThat(IntStream actual)
Creates a new instance of
from the given IntStream . |
static AbstractListAssert<?,List<? extends Integer>,Integer,ObjectAssert<Integer>> |
Assertions.assertThat(IntStream actual)
Creates a new instance of
from the given IntStream . |
AbstractListAssert<?,List<? extends Integer>,Integer,ObjectAssert<Integer>> |
AbstractStandardSoftAssertions.assertThat(IntStream actual)
Creates a new instance of
from the given IntStream . |
static <ELEMENT> IterableAssert<ELEMENT> |
AssertionsForInterfaceTypes.assertThat(Iterable<? extends ELEMENT> actual)
Creates a new instance of
. |
static <ELEMENT> IterableAssert<ELEMENT> |
Assertions.assertThat(Iterable<? extends ELEMENT> actual)
Creates a new instance of
. |
default <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
WithAssertions.assertThat(Iterable<? extends ELEMENT> actual,
AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
Creates a new instance of
allowing to navigate to any Iterable element
in order to perform assertions on it. |
static <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
Assertions.assertThat(Iterable<? extends ELEMENT> actual,
AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
Creates a new instance of
allowing to navigate to any Iterable element
in order to perform assertions on it. |
<T> SoftAssertionIterableAssert<T> |
Java6AbstractStandardSoftAssertions.assertThat(Iterable<? extends T> actual)
Creates a new instance of
. |
default <T> IterableAssert<T> |
WithAssertions.assertThat(Iterable<? extends T> actual)
Creates a new instance of
. |
static <T> AbstractIterableAssert<?,Iterable<? extends T>,T,ObjectAssert<T>> |
Java6Assertions.assertThat(Iterable<? extends T> actual)
Creates a new instance of
. |
static <ELEMENT> IterableAssert<ELEMENT> |
AssertionsForInterfaceTypes.assertThat(Iterator<? extends ELEMENT> actual)
Creates a new instance of
. |
static <ELEMENT> IterableAssert<ELEMENT> |
Assertions.assertThat(Iterator<? extends ELEMENT> actual)
Creates a new instance of
. |
<T> SoftAssertionIterableAssert<T> |
Java6AbstractStandardSoftAssertions.assertThat(Iterator<? extends T> actual)
Creates a new instance of
. |
default <T> IterableAssert<T> |
WithAssertions.assertThat(Iterator<? extends T> actual)
Creates a new instance of
. |
static <T> AbstractIterableAssert<?,Iterable<? extends T>,T,ObjectAssert<T>> |
Java6Assertions.assertThat(Iterator<? extends T> actual)
Creates a new instance of
. |
static <ELEMENT> ListAssert<ELEMENT> |
AssertionsForInterfaceTypes.assertThat(List<? extends ELEMENT> actual)
Creates a new instance of
. |
static <ELEMENT> ListAssert<ELEMENT> |
Assertions.assertThat(List<? extends ELEMENT> actual)
Creates a new instance of
. |
default <ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
WithAssertions.assertThat(List<? extends ELEMENT> actual,
AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
Creates a new instance of
allowing to navigate to any List element
in order to perform assertions on it. |
static <ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
Assertions.assertThat(List<? extends ELEMENT> actual,
AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
Creates a new instance of
allowing to navigate to any List element
in order to perform assertions on it. |
default <ELEMENT,ACTUAL extends List<? extends ELEMENT>,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
WithAssertions.assertThat(List<? extends ELEMENT> actual,
Class<ELEMENT_ASSERT> assertClass)
Creates a new instance of
tallowing to navigate to any List element
in order to perform assertions on it. |
static <ELEMENT,ACTUAL extends List<? extends ELEMENT>,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
Assertions.assertThat(List<? extends ELEMENT> actual,
Class<ELEMENT_ASSERT> assertClass)
Creates a new instance of
tallowing to navigate to any List element
in order to perform assertions on it. |
<T> SoftAssertionListAssert<T> |
Java6AbstractStandardSoftAssertions.assertThat(List<? extends T> actual)
Creates a new instance of
. |
default <T> ListAssert<T> |
WithAssertions.assertThat(List<? extends T> actual)
Creates a new instance of
. |
static <T> AbstractListAssert<?,List<? extends T>,T,ObjectAssert<T>> |
Java6Assertions.assertThat(List<? extends T> actual)
Creates a new instance of
. |
static AbstractLocalDateAssert<?> |
Assertions.assertThat(LocalDate actual)
Creates a new instance of
. |
LocalDateAssert |
AbstractStandardSoftAssertions.assertThat(LocalDate actual)
Creates a new instance of
. |
static AbstractLocalDateAssert<?> |
AssertionsForClassTypes.assertThat(LocalDate localDate)
Creates a new instance of
. |
static AbstractLocalDateTimeAssert<?> |
Assertions.assertThat(LocalDateTime actual)
Creates a new instance of
. |
LocalDateTimeAssert |
AbstractStandardSoftAssertions.assertThat(LocalDateTime actual)
Creates a new instance of
. |
static AbstractLocalDateTimeAssert<?> |
AssertionsForClassTypes.assertThat(LocalDateTime actual)
Creates a new instance of
. |
static AbstractLocalTimeAssert<?> |
Assertions.assertThat(LocalTime actual)
Creates a new instance of
. |
LocalTimeAssert |
AbstractStandardSoftAssertions.assertThat(LocalTime actual)
Creates a new instance of
. |
static AbstractLocalTimeAssert<?> |
AssertionsForClassTypes.assertThat(LocalTime actual)
Creates a new instance of
. |
LongAssert |
Java6AbstractStandardSoftAssertions.assertThat(long actual)
Creates a new instance of
. |
default AbstractLongAssert<?> |
WithAssertions.assertThat(long actual)
Creates a new instance of
. |
static AbstractLongAssert<?> |
Assertions.assertThat(long actual)
Creates a new instance of
. |
static AbstractLongAssert<?> |
AssertionsForClassTypes.assertThat(long actual)
Creates a new instance of
. |
static AbstractLongAssert<?> |
Java6Assertions.assertThat(long actual)
Creates a new instance of
. |
LongAssert |
Java6AbstractStandardSoftAssertions.assertThat(Long actual)
Creates a new instance of
. |
default AbstractLongAssert<?> |
WithAssertions.assertThat(Long actual)
Creates a new instance of
. |
static AbstractLongAssert<?> |
Assertions.assertThat(Long actual)
Creates a new instance of
. |
static AbstractLongAssert<?> |
AssertionsForClassTypes.assertThat(Long actual)
Creates a new instance of
. |
static AbstractLongAssert<?> |
Java6Assertions.assertThat(Long actual)
Creates a new instance of
. |
LongArrayAssert |
Java6AbstractStandardSoftAssertions.assertThat(long[] actual)
Creates a new instance of
. |
default AbstractLongArrayAssert<?> |
WithAssertions.assertThat(long[] actual)
Creates a new instance of
. |
static AbstractLongArrayAssert<?> |
Assertions.assertThat(long[] actual)
Creates a new instance of
. |
static AbstractLongArrayAssert<?> |
AssertionsForClassTypes.assertThat(long[] actual)
Creates a new instance of
. |
static AbstractLongArrayAssert<?> |
Java6Assertions.assertThat(long[] actual)
Creates a new instance of
. |
static LongPredicateAssert |
AssertionsForInterfaceTypes.assertThat(LongPredicate actual)
Create assertion for
LongPredicate . |
static LongPredicateAssert |
Assertions.assertThat(LongPredicate actual)
Create assertion for
LongPredicate . |
LongPredicateAssert |
AbstractStandardSoftAssertions.assertThat(LongPredicate actual)
Create assertion for
DoublePredicate . |
default AbstractListAssert<?,List<? extends Long>,Long,ObjectAssert<Long>> |
WithAssertions.assertThat(LongStream actual)
Creates a new instance of
from the given LongStream . |
static AbstractListAssert<?,List<? extends Long>,Long,ObjectAssert<Long>> |
AssertionsForInterfaceTypes.assertThat(LongStream actual)
Creates a new instance of
from the given LongStream . |
static AbstractListAssert<?,List<? extends Long>,Long,ObjectAssert<Long>> |
Assertions.assertThat(LongStream actual)
Creates a new instance of
from the given LongStream . |
AbstractListAssert<?,List<? extends Long>,Long,ObjectAssert<Long>> |
AbstractStandardSoftAssertions.assertThat(LongStream actual)
Creates a new instance of
from the given LongStream . |
<K,V> SoftAssertionMapAssert<K,V> |
Java6AbstractStandardSoftAssertions.assertThat(Map<K,V> actual)
Creates a new instance of
. |
default <K,V> MapAssert<K,V> |
WithAssertions.assertThat(Map<K,V> actual)
Creates a new instance of
. |
static <K,V> MapAssert<K,V> |
AssertionsForInterfaceTypes.assertThat(Map<K,V> actual)
Creates a new instance of
. |
static <K,V> MapAssert<K,V> |
Assertions.assertThat(Map<K,V> actual)
Creates a new instance of
. |
static <K,V> MapAssert<K,V> |
Java6Assertions.assertThat(Map<K,V> actual)
Creates a new instance of
. |
static AbstractOffsetDateTimeAssert<?> |
Assertions.assertThat(OffsetDateTime actual)
Creates a new instance of
. |
OffsetDateTimeAssert |
AbstractStandardSoftAssertions.assertThat(OffsetDateTime actual)
Creates a new instance of
. |
static AbstractOffsetDateTimeAssert<?> |
AssertionsForClassTypes.assertThat(OffsetDateTime actual)
Creates a new instance of
. |
static AbstractOffsetTimeAssert<?> |
Assertions.assertThat(OffsetTime actual)
Create assertion for
OffsetTime . |
OffsetTimeAssert |
AbstractStandardSoftAssertions.assertThat(OffsetTime actual)
Creates a new instance of
. |
static AbstractOffsetTimeAssert<?> |
AssertionsForClassTypes.assertThat(OffsetTime actual)
Create assertion for
OffsetTime . |
static <VALUE> OptionalAssert<VALUE> |
Assertions.assertThat(Optional<VALUE> actual)
Create assertion for
Optional . |
<VALUE> OptionalAssert<VALUE> |
AbstractStandardSoftAssertions.assertThat(Optional<VALUE> actual)
Create assertion for
Optional . |
static <VALUE> OptionalAssert<VALUE> |
AssertionsForClassTypes.assertThat(Optional<VALUE> actual)
Create assertion for
Optional . |
static OptionalDoubleAssert |
Assertions.assertThat(OptionalDouble actual)
Create assertion for
OptionalDouble . |
OptionalDoubleAssert |
AbstractStandardSoftAssertions.assertThat(OptionalDouble actual)
Create assertion for
OptionalDouble . |
static OptionalDoubleAssert |
AssertionsForClassTypes.assertThat(OptionalDouble actual)
Create assertion for
OptionalDouble . |
static OptionalIntAssert |
Assertions.assertThat(OptionalInt actual)
Create assertion for
OptionalInt . |
OptionalIntAssert |
AbstractStandardSoftAssertions.assertThat(OptionalInt actual)
Create assertion for
OptionalInt . |
static OptionalIntAssert |
AssertionsForClassTypes.assertThat(OptionalInt actual)
Create assertion for
OptionalInt . |
static OptionalLongAssert |
Assertions.assertThat(OptionalLong actual)
Create assertion for
OptionalInt . |
OptionalLongAssert |
AbstractStandardSoftAssertions.assertThat(OptionalLong actual)
Create assertion for
OptionalLong . |
static OptionalLongAssert |
AssertionsForClassTypes.assertThat(OptionalLong actual)
Create assertion for
OptionalInt . |
default AbstractPathAssert<?> |
WithAssertions.assertThat(Path actual)
Creates a new instance of
PathAssert |
static AbstractPathAssert<?> |
AssertionsForInterfaceTypes.assertThat(Path actual)
Creates a new instance of
PathAssert |
static AbstractPathAssert<?> |
Assertions.assertThat(Path actual)
Creates a new instance of
PathAssert |
PathAssert |
AbstractStandardSoftAssertions.assertThat(Path actual)
Creates a new, proxied instance of a
PathAssert |
static <T> PredicateAssert<T> |
AssertionsForInterfaceTypes.assertThat(Predicate<T> actual)
Create assertion for
Predicate . |
static <T> PredicateAssert<T> |
Assertions.assertThat(Predicate<T> actual)
Create assertion for
Predicate . |
<T> SoftAssertionPredicateAssert<T> |
AbstractStandardSoftAssertions.assertThat(Predicate<T> actual)
Create assertion for
Predicate . |
ShortAssert |
Java6AbstractStandardSoftAssertions.assertThat(short actual)
Creates a new instance of
. |
default AbstractShortAssert<?> |
WithAssertions.assertThat(short actual)
Creates a new instance of
. |
static AbstractShortAssert<?> |
Assertions.assertThat(short actual)
Creates a new instance of
. |
static AbstractShortAssert<?> |
AssertionsForClassTypes.assertThat(short actual)
Creates a new instance of
. |
static AbstractShortAssert<?> |
Java6Assertions.assertThat(short actual)
Creates a new instance of
. |
ShortAssert |
Java6AbstractStandardSoftAssertions.assertThat(Short actual)
Creates a new instance of
. |
default AbstractShortAssert<?> |
WithAssertions.assertThat(Short actual)
Creates a new instance of
. |
static AbstractShortAssert<?> |
Assertions.assertThat(Short actual)
Creates a new instance of
. |
static AbstractShortAssert<?> |
AssertionsForClassTypes.assertThat(Short actual)
Creates a new instance of
. |
static AbstractShortAssert<?> |
Java6Assertions.assertThat(Short actual)
Creates a new instance of
. |
ShortArrayAssert |
Java6AbstractStandardSoftAssertions.assertThat(short[] actual)
Creates a new instance of
. |
default AbstractShortArrayAssert<?> |
WithAssertions.assertThat(short[] actual)
Creates a new instance of
. |
static AbstractShortArrayAssert<?> |
Assertions.assertThat(short[] actual)
Creates a new instance of
. |
static AbstractShortArrayAssert<?> |
AssertionsForClassTypes.assertThat(short[] actual)
Creates a new instance of
. |
static AbstractShortArrayAssert<?> |
Java6Assertions.assertThat(short[] actual)
Creates a new instance of
. |
default <ELEMENT> AbstractListAssert<?,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>> |
WithAssertions.assertThat(Stream<? extends ELEMENT> actual)
Creates a new instance of
from the given Stream . |
static <ELEMENT> AbstractListAssert<?,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>> |
AssertionsForInterfaceTypes.assertThat(Stream<? extends ELEMENT> actual)
Creates a new instance of
from the given Stream . |
static <ELEMENT> AbstractListAssert<?,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>> |
Assertions.assertThat(Stream<? extends ELEMENT> actual)
Creates a new instance of
from the given Stream . |
<ELEMENT> AbstractListAssert<?,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>> |
AbstractStandardSoftAssertions.assertThat(Stream<? extends ELEMENT> actual)
Creates a new instance of
from the given Stream . |
StringAssert |
Java6AbstractStandardSoftAssertions.assertThat(String actual)
Creates a new instance of
. |
default AbstractCharSequenceAssert<?,String> |
WithAssertions.assertThat(String actual)
Creates a new instance of
. |
static AbstractCharSequenceAssert<?,String> |
Assertions.assertThat(String actual)
Creates a new instance of
. |
static AbstractCharSequenceAssert<?,String> |
AssertionsForClassTypes.assertThat(String actual)
Creates a new instance of
. |
static AbstractCharSequenceAssert<?,String> |
Java6Assertions.assertThat(String actual)
Creates a new instance of
. |
<T> ObjectAssert<T> |
Java6AbstractStandardSoftAssertions.assertThat(T actual)
Creates a new instance of
. |
default <T> AbstractObjectAssert<?,T> |
WithAssertions.assertThat(T actual)
Creates a new instance of
. |
static <T> AbstractObjectAssert<?,T> |
Assertions.assertThat(T actual)
Creates a new instance of
. |
static <T> AbstractObjectAssert<?,T> |
AssertionsForClassTypes.assertThat(T actual)
Creates a new instance of
. |
static <T> AbstractObjectAssert<?,T> |
Java6Assertions.assertThat(T actual)
Creates a new instance of
. |
<T extends Comparable<? super T>> |
Java6AbstractStandardSoftAssertions.assertThat(T actual)
Creates a new instance of
with
standard comparison semantics. |
default <T extends Comparable<? super T>> |
WithAssertions.assertThat(T actual)
Creates a new instance of
with
standard comparison semantics. |
static <T extends Comparable<? super T>> |
AssertionsForInterfaceTypes.assertThat(T actual)
Creates a new instance of
with
standard comparison semantics. |
static <T extends Comparable<? super T>> |
Assertions.assertThat(T actual)
Creates a new instance of
with
standard comparison semantics. |
static <T extends Comparable<? super T>> |
Java6Assertions.assertThat(T actual)
Creates a new instance of
with
standard comparison semantics. |
default <T extends AssertDelegateTarget> |
WithAssertions.assertThat(T assertion)
Returns the given assertion.
|
static <T extends AssertDelegateTarget> |
AssertionsForInterfaceTypes.assertThat(T assertion)
Returns the given assertion.
|
static <T extends AssertDelegateTarget> |
Assertions.assertThat(T assertion)
Returns the given assertion.
|
static <T extends AssertDelegateTarget> |
Java6Assertions.assertThat(T assertion)
Returns the given assertion.
|
<T> ObjectArrayAssert<T> |
Java6AbstractStandardSoftAssertions.assertThat(T[] actual)
Creates a new instance of
. |
default <T> AbstractObjectArrayAssert<?,T> |
WithAssertions.assertThat(T[] actual)
Creates a new instance of
. |
static <T> AbstractObjectArrayAssert<?,T> |
Assertions.assertThat(T[] actual)
Creates a new instance of
. |
static <T> AbstractObjectArrayAssert<?,T> |
AssertionsForClassTypes.assertThat(T[] actual)
Creates a new instance of
. |
static <T> AbstractObjectArrayAssert<?,T> |
Java6Assertions.assertThat(T[] actual)
Creates a new instance of
. |
ThrowableAssert |
Java6AbstractStandardSoftAssertions.assertThat(Throwable actual)
Creates a new instance of
. |
default AbstractThrowableAssert<?,? extends Throwable> |
WithAssertions.assertThat(Throwable actual)
Creates a new instance of
. |
static AbstractThrowableAssert<?,? extends Throwable> |
Assertions.assertThat(Throwable actual)
Creates a new instance of
. |
static AbstractThrowableAssert<?,? extends Throwable> |
AssertionsForClassTypes.assertThat(Throwable actual)
Creates a new instance of
. |
static AbstractThrowableAssert<?,? extends Throwable> |
Java6Assertions.assertThat(Throwable actual)
Creates a new instance of
. |
UriAssert |
Java6AbstractStandardSoftAssertions.assertThat(URI actual)
Creates a new instance of
. |
static AbstractUriAssert<?> |
Assertions.assertThat(URI actual)
Creates a new instance of
. |
static AbstractUriAssert<?> |
AssertionsForClassTypes.assertThat(URI actual)
Creates a new instance of
. |
static AbstractUriAssert<?> |
Java6Assertions.assertThat(URI actual)
Creates a new instance of
. |
AbstractUrlAssert<?> |
Java6AbstractStandardSoftAssertions.assertThat(URL actual)
Creates a new instance of
. |
static AbstractUrlAssert<?> |
Assertions.assertThat(URL actual)
Creates a new instance of
. |
static AbstractUrlAssert<?> |
AssertionsForClassTypes.assertThat(URL actual)
Creates a new instance of
. |
static AbstractUrlAssert<?> |
Java6Assertions.assertThat(URL actual)
Creates a new instance of
. |
static AbstractZonedDateTimeAssert<?> |
Assertions.assertThat(ZonedDateTime actual)
Creates a new instance of
. |
ZonedDateTimeAssert |
AbstractStandardSoftAssertions.assertThat(ZonedDateTime actual)
Creates a new instance of
. |
static AbstractZonedDateTimeAssert<?> |
AssertionsForClassTypes.assertThat(ZonedDateTime actual)
Creates a new instance of
. |
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. |
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 AbstractThrowableAssert<?,? extends Throwable> |
Assertions.assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)
Allows to capture and then assert on a
Throwable (easier done with 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. |
static AbstractThrowableAssert<?,? extends Throwable> |
Java6Assertions.assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)
Allows to capture and then assert on a
Throwable . |
static <T extends Throwable> |
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> |
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. |
default ThrowableTypeAssert<IllegalArgumentException> |
WithAssertions.assertThatIllegalArgumentException()
|
static ThrowableTypeAssert<IllegalArgumentException> |
Assertions.assertThatIllegalArgumentException()
|
default ThrowableTypeAssert<IllegalStateException> |
WithAssertions.assertThatIllegalStateException()
|
static ThrowableTypeAssert<IllegalStateException> |
Assertions.assertThatIllegalStateException()
Alias for
Assertions.assertThatExceptionOfType(Class) for IllegalStateException . |
default ThrowableTypeAssert<IOException> |
WithAssertions.assertThatIOException()
Alias for
WithAssertions.assertThatExceptionOfType(Class) for IOException . |
static ThrowableTypeAssert<IOException> |
Assertions.assertThatIOException()
Alias for
Assertions.assertThatExceptionOfType(Class) for IOException . |
default ThrowableTypeAssert<NullPointerException> |
WithAssertions.assertThatNullPointerException()
|
static ThrowableTypeAssert<NullPointerException> |
Assertions.assertThatNullPointerException()
Alias for
Assertions.assertThatExceptionOfType(Class) for NullPointerException . |
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> |
Assertions.assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Allows to capture and then assert on a
Throwable (easier done with lambdas). |
static AbstractThrowableAssert<?,? extends Throwable> |
AssertionsForClassTypes.assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Allows to capture and then assert on a
Throwable (easier done with 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.
|
static AtomicBooleanAssert |
Assumptions.assumeThat(AtomicBoolean actual)
Create assumption for
AtomicBoolean . |
static AtomicIntegerAssert |
Assumptions.assumeThat(AtomicInteger actual)
Create assumption for
AtomicInteger . |
static AtomicIntegerArrayAssert |
Assumptions.assumeThat(AtomicIntegerArray actual)
Creates int[] assumption for
AtomicIntegerArray . |
static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT> |
Assumptions.assumeThat(AtomicIntegerFieldUpdater<OBJECT> actual)
Create assumption for
AtomicIntegerFieldUpdater . |
static AtomicLongAssert |
Assumptions.assumeThat(AtomicLong actual)
Create assumption for
AtomicLong . |
static AtomicLongArrayAssert |
Assumptions.assumeThat(AtomicLongArray actual)
Create assumption for
AtomicLongArray . |
static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT> |
Assumptions.assumeThat(AtomicLongFieldUpdater<OBJECT> actual)
Create assumption for
AtomicLongFieldUpdater . |
static <VALUE> AtomicMarkableReferenceAssert<VALUE> |
Assumptions.assumeThat(AtomicMarkableReference<VALUE> actual)
Create assumption for
AtomicMarkableReference . |
static <VALUE> AtomicReferenceAssert<VALUE> |
Assumptions.assumeThat(AtomicReference<VALUE> actual)
Create assumption for
AtomicReference . |
static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT> |
Assumptions.assumeThat(AtomicReferenceArray<ELEMENT> actual)
Create assumption for
AtomicReferenceArray . |
static <FIELD,OBJECT> |
Assumptions.assumeThat(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)
Create assumption for
AtomicReferenceFieldUpdater . |
static <VALUE> AtomicStampedReferenceAssert<VALUE> |
Assumptions.assumeThat(AtomicStampedReference<VALUE> actual)
Create assumption for
AtomicStampedReference . |
static AbstractBigDecimalAssert<?> |
Assumptions.assumeThat(BigDecimal actual)
Creates a new instance of
assumption. |
default AbstractBigDecimalAssert<?> |
WithAssumptions.assumeThat(BigDecimal actual)
Creates a new instance of
assumption. |
static AbstractBigIntegerAssert<?> |
Assumptions.assumeThat(BigInteger actual)
Creates a new instance of
assumption. |
default AbstractBigIntegerAssert<?> |
WithAssumptions.assumeThat(BigInteger actual)
Creates a new instance of
assumption. |
static AbstractBooleanAssert<?> |
Assumptions.assumeThat(boolean actual)
Creates a new instance of
assumption. |
default AbstractBooleanAssert<?> |
WithAssumptions.assumeThat(boolean actual)
Creates a new instance of
assumption. |
static AbstractBooleanAssert<?> |
Assumptions.assumeThat(Boolean actual)
Creates a new instance of
assumption. |
default AbstractBooleanAssert<?> |
WithAssumptions.assumeThat(Boolean actual)
Creates a new instance of
assumption. |
static AbstractBooleanArrayAssert<?> |
Assumptions.assumeThat(boolean[] actual)
Creates a new instance of
assumption. |
default AbstractBooleanArrayAssert<?> |
WithAssumptions.assumeThat(boolean[] actual)
Creates a new instance of
assumption. |
static AbstractByteAssert<?> |
Assumptions.assumeThat(byte actual)
Creates a new instance of
assumption. |
default AbstractByteAssert<?> |
WithAssumptions.assumeThat(byte actual)
Creates a new instance of
assumption. |
static AbstractByteAssert<?> |
Assumptions.assumeThat(Byte actual)
Creates a new instance of
assumption. |
default AbstractByteAssert<?> |
WithAssumptions.assumeThat(Byte actual)
Creates a new instance of
assumption. |
static AbstractByteArrayAssert<?> |
Assumptions.assumeThat(byte[] actual)
Creates a new instance of
assumption. |
default AbstractByteArrayAssert<?> |
WithAssumptions.assumeThat(byte[] actual)
Creates a new instance of
assumption. |
static AbstractCharacterAssert<?> |
Assumptions.assumeThat(char actual)
Creates a new instance of
assumption. |
default AbstractCharacterAssert<?> |
WithAssumptions.assumeThat(char actual)
Creates a new instance of
assumption. |
static AbstractCharArrayAssert<?> |
Assumptions.assumeThat(char[] actual)
Creates a new instance of
assumption. |
default AbstractCharArrayAssert<?> |
WithAssumptions.assumeThat(char[] actual)
Creates a new instance of
assumption. |
static AbstractCharacterAssert<?> |
Assumptions.assumeThat(Character actual)
Creates a new instance of
assumption. |
default AbstractCharacterAssert<?> |
WithAssumptions.assumeThat(Character actual)
Creates a new instance of
assumption. |
static AbstractCharSequenceAssert<?,? extends CharSequence> |
Assumptions.assumeThat(CharSequence actual)
Creates a new instance of
assumption. |
default AbstractCharSequenceAssert<?,? extends CharSequence> |
WithAssumptions.assumeThat(CharSequence actual)
Creates a new instance of
assumption. |
static AbstractClassAssert<?> |
Assumptions.assumeThat(Class<?> actual)
Creates a new instance of
assumption. |
default AbstractClassAssert<?> |
WithAssumptions.assumeThat(Class<?> actual)
Creates a new instance of
assumption. |
static <RESULT> CompletableFutureAssert<RESULT> |
Assumptions.assumeThat(CompletableFuture<RESULT> actual)
Creates a new instance of
CompletableFutureAssert assumption. |
static <RESULT> CompletableFutureAssert<RESULT> |
Assumptions.assumeThat(CompletionStage<RESULT> actual)
Creates a new instance of
CompletableFutureAssert assumption for a CompletionStage
by converting it to a CompletableFuture and returning a CompletableFutureAssert . |
default <RESULT> CompletableFutureAssert<RESULT> |
WithAssumptions.assumeThat(CompletionStage<RESULT> actual)
Creates a new instance of
CompletableFutureAssert assumption for a CompletionStage
by converting it to a CompletableFuture and returning a CompletableFutureAssert . |
static AbstractDateAssert<?> |
Assumptions.assumeThat(Date actual)
Creates a new instance of
assumption. |
default AbstractDateAssert<?> |
WithAssumptions.assumeThat(Date actual)
Creates a new instance of
assumption. |
static AbstractDoubleAssert<?> |
Assumptions.assumeThat(double actual)
Creates a new instance of
assumption. |
default AbstractDoubleAssert<?> |
WithAssumptions.assumeThat(double actual)
Creates a new instance of
assumption. |
static AbstractDoubleAssert<?> |
Assumptions.assumeThat(Double actual)
Creates a new instance of
assumption. |
default AbstractDoubleAssert<?> |
WithAssumptions.assumeThat(Double actual)
Creates a new instance of
assumption. |
static AbstractDoubleArrayAssert<?> |
Assumptions.assumeThat(double[] actual)
Creates a new instance of
assumption. |
default AbstractDoubleArrayAssert<?> |
WithAssumptions.assumeThat(double[] actual)
Creates a new instance of
assumption. |
static DoublePredicateAssert |
Assumptions.assumeThat(DoublePredicate actual)
Creates a new instance of
DoublePredicateAssert assumption. |
static AbstractListAssert<?,List<? extends Double>,Double,ObjectAssert<Double>> |
Assumptions.assumeThat(DoubleStream actual)
Creates a new instance of
assumption from the given DoubleStream . |
default AbstractListAssert<?,List<? extends Double>,Double,ObjectAssert<Double>> |
WithAssumptions.assumeThat(DoubleStream doubleStream)
Creates a new instance of
assumption from the given DoubleStream . |
static AbstractFileAssert<?> |
Assumptions.assumeThat(File actual)
Creates a new instance of
assumption. |
default AbstractFileAssert<?> |
WithAssumptions.assumeThat(File actual)
Creates a new instance of
assumption. |
static AbstractFloatAssert<?> |
Assumptions.assumeThat(float actual)
Creates a new instance of
assumption. |
default AbstractFloatAssert<?> |
WithAssumptions.assumeThat(float actual)
Creates a new instance of
assumption. |
static AbstractFloatAssert<?> |
Assumptions.assumeThat(Float actual)
Creates a new instance of
assumption. |
default AbstractFloatAssert<?> |
WithAssumptions.assumeThat(Float actual)
Creates a new instance of
assumption. |
static AbstractFloatArrayAssert<?> |
Assumptions.assumeThat(float[] actual)
Creates a new instance of
assumption. |
default AbstractFloatArrayAssert<?> |
WithAssumptions.assumeThat(float[] actual)
Creates a new instance of
assumption. |
static <RESULT> AbstractFutureAssert<?,? extends Future<? extends RESULT>,RESULT> |
Assumptions.assumeThat(Future<RESULT> future)
Create assertion for
FutureAssert assumption. |
default <RESULT> AbstractFutureAssert<?,? extends Future<? extends RESULT>,RESULT> |
WithAssumptions.assumeThat(Future<RESULT> actual)
Create assertion for
FutureAssert assumption. |
static AbstractInputStreamAssert<?,? extends InputStream> |
Assumptions.assumeThat(InputStream actual)
Creates a new instance of
assumption. |
default AbstractInputStreamAssert<?,? extends InputStream> |
WithAssumptions.assumeThat(InputStream actual)
Creates a new instance of
assumption. |
static AbstractInstantAssert<?> |
Assumptions.assumeThat(Instant actual)
Creates a new instance of
InstantAssert assumption. |
static AbstractIntegerAssert<?> |
Assumptions.assumeThat(int actual)
Creates a new instance of
assumption. |
default AbstractIntegerAssert<?> |
WithAssumptions.assumeThat(int actual)
Creates a new instance of
assumption. |
static AbstractIntArrayAssert<?> |
Assumptions.assumeThat(int[] actual)
Creates a new instance of
assumption. |
default AbstractIntArrayAssert<?> |
WithAssumptions.assumeThat(int[] actual)
Creates a new instance of
assumption. |
static AbstractIntegerAssert<?> |
Assumptions.assumeThat(Integer actual)
Creates a new instance of
assumption. |
default AbstractIntegerAssert<?> |
WithAssumptions.assumeThat(Integer actual)
Creates a new instance of
assumption. |
static IntPredicateAssert |
Assumptions.assumeThat(IntPredicate actual)
Creates a new instance of
IntPredicateAssert assumption. |
static AbstractListAssert<?,List<? extends Integer>,Integer,ObjectAssert<Integer>> |
Assumptions.assumeThat(IntStream actual)
Creates a new instance of
assumption from the given IntStream . |
default AbstractListAssert<?,List<? extends Integer>,Integer,ObjectAssert<Integer>> |
WithAssumptions.assumeThat(IntStream intStream)
Creates a new instance of
assumption from the given IntStream . |
static <ELEMENT> FactoryBasedNavigableIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>> |
Assumptions.assumeThat(Iterable<? extends ELEMENT> actual)
Creates a new instance of
assumption. |
default <ELEMENT> FactoryBasedNavigableIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>> |
WithAssumptions.assumeThat(Iterable<? extends ELEMENT> actual)
Creates a new instance of
assumption. |
static <ELEMENT> FactoryBasedNavigableIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>> |
Assumptions.assumeThat(Iterator<? extends ELEMENT> actual)
Creates a new instance of
assumption. |
default <ELEMENT> FactoryBasedNavigableIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>> |
WithAssumptions.assumeThat(Iterator<? extends ELEMENT> actual)
Creates a new instance of
assumption. |
static <ELEMENT> FactoryBasedNavigableListAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>> |
Assumptions.assumeThat(List<? extends ELEMENT> actual)
Creates a new instance of
assumption. |
default <ELEMENT> FactoryBasedNavigableListAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>> |
WithAssumptions.assumeThat(List<? extends ELEMENT> list)
Creates a new instance of
assumption. |
static AbstractLocalDateAssert<?> |
Assumptions.assumeThat(LocalDate actual)
Creates a new instance of
LocalDateAssert assumption. |
static AbstractLocalDateTimeAssert<?> |
Assumptions.assumeThat(LocalDateTime actual)
Creates a new instance of
LocalDateTimeAssert assumption. |
static AbstractLocalTimeAssert<?> |
Assumptions.assumeThat(LocalTime actual)
Creates a new instance of
LocalTimeAssert assumption. |
static AbstractLongAssert<?> |
Assumptions.assumeThat(long actual)
Creates a new instance of
assumption. |
default AbstractLongAssert<?> |
WithAssumptions.assumeThat(long actual)
Creates a new instance of
assumption. |
static AbstractLongAssert<?> |
Assumptions.assumeThat(Long actual)
Creates a new instance of
assumption. |
default AbstractLongAssert<?> |
WithAssumptions.assumeThat(Long actual)
Creates a new instance of
assumption. |
static AbstractLongArrayAssert<?> |
Assumptions.assumeThat(long[] actual)
Creates a new instance of
assumption. |
default AbstractLongArrayAssert<?> |
WithAssumptions.assumeThat(long[] actual)
Creates a new instance of
assumption. |
static LongPredicateAssert |
Assumptions.assumeThat(LongPredicate actual)
Creates a new instance of
LongPredicateAssert assumption. |
static AbstractListAssert<?,List<? extends Long>,Long,ObjectAssert<Long>> |
Assumptions.assumeThat(LongStream actual)
Creates a new instance of
assumption from the given LongStream . |
default AbstractListAssert<?,List<? extends Long>,Long,ObjectAssert<Long>> |
WithAssumptions.assumeThat(LongStream longStream)
Creates a new instance of
assumption from the given LongStream . |
static <K,V> AbstractMapAssert<?,?,K,V> |
Assumptions.assumeThat(Map<K,V> actual)
Creates a new instance of
assumption. |
default <K,V> AbstractMapAssert<?,?,K,V> |
WithAssumptions.assumeThat(Map<K,V> actual)
Creates a new instance of
assumption. |
static AbstractOffsetDateTimeAssert<?> |
Assumptions.assumeThat(OffsetDateTime actual)
Creates a new instance of
OffsetDateTimeAssert assumption. |
static AbstractOffsetTimeAssert<?> |
Assumptions.assumeThat(OffsetTime actual)
Creates a new instance of
OffsetTimeAssert assumption. |
static <VALUE> OptionalAssert<VALUE> |
Assumptions.assumeThat(Optional<VALUE> actual)
Creates a new instance of
OptionalAssert assumption. |
static OptionalDoubleAssert |
Assumptions.assumeThat(OptionalDouble actual)
Creates a new instance of
OptionalDoubleAssert assumption. |
static OptionalIntAssert |
Assumptions.assumeThat(OptionalInt actual)
Creates a new instance of
OptionalIntAssert assumption. |
static OptionalLongAssert |
Assumptions.assumeThat(OptionalLong actual)
Creates a new instance of
OptionalLongAssert assumption. |
static AbstractPathAssert<?> |
Assumptions.assumeThat(Path actual)
Creates a new instance of
PathAssert assumption. |
default AbstractPathAssert<?> |
WithAssumptions.assumeThat(Path actual)
Creates a new instance of
assumption. |
static <T> PredicateAssert<T> |
Assumptions.assumeThat(Predicate<T> actual)
Creates a new instance of
PredicateAssert assumption. |
static AbstractShortAssert<?> |
Assumptions.assumeThat(short actual)
Creates a new instance of
assumption. |
default AbstractShortAssert<?> |
WithAssumptions.assumeThat(short actual)
Creates a new instance of
assumption. |
static AbstractShortAssert<?> |
Assumptions.assumeThat(Short actual)
Creates a new instance of
assumption. |
default AbstractShortAssert<?> |
WithAssumptions.assumeThat(Short actual)
Creates a new instance of
assumption. |
static AbstractShortArrayAssert<?> |
Assumptions.assumeThat(short[] actual)
Creates a new instance of
assumption. |
default AbstractShortArrayAssert<?> |
WithAssumptions.assumeThat(short[] actual)
Creates a new instance of
assumption. |
static <ELEMENT> AbstractListAssert<?,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>> |
Assumptions.assumeThat(Stream<? extends ELEMENT> actual)
Creates a new instance of
assumption from the given Stream . |
default <ELEMENT> AbstractListAssert<?,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>> |
WithAssumptions.assumeThat(Stream<? extends ELEMENT> stream)
Creates a new instance of
assumption from the given Stream . |
static AbstractCharSequenceAssert<?,String> |
Assumptions.assumeThat(String actual)
Creates a new instance of
assumption. |
default AbstractCharSequenceAssert<?,String> |
WithAssumptions.assumeThat(String actual)
Creates a new instance of
assumption. |
static <T> AbstractObjectAssert<?,T> |
Assumptions.assumeThat(T actual)
Creates a new instance of
assumption. |
default <T> AbstractObjectAssert<?,T> |
WithAssumptions.assumeThat(T actual)
Creates a new instance of
assumption. |
static <T extends Comparable<? super T>> |
Assumptions.assumeThat(T actual)
Creates a new instance of
assumption. |
default <T extends Comparable<? super T>> |
WithAssumptions.assumeThat(T actual)
Creates a new instance of
assumption. |
static <T> AbstractObjectArrayAssert<?,T> |
Assumptions.assumeThat(T[] actual)
Creates a new instance of
assumption. |
default <T> AbstractObjectArrayAssert<?,T> |
WithAssumptions.assumeThat(T[] actual)
Creates a new instance of
assumption. |
static AbstractThrowableAssert<?,? extends Throwable> |
Assumptions.assumeThat(Throwable actual)
Creates a new instance of
assumption. |
default AbstractThrowableAssert<?,? extends Throwable> |
WithAssumptions.assumeThat(Throwable actual)
Creates a new instance of
assumption. |
static AbstractUriAssert<?> |
Assumptions.assumeThat(URI actual)
Creates a new instance of
assumption. |
static AbstractUrlAssert<?> |
Assumptions.assumeThat(URL actual)
Creates a new instance of
assumption. |
static AbstractZonedDateTimeAssert<?> |
Assumptions.assumeThat(ZonedDateTime actual)
Creates a new instance of
ZonedDateTimeAssert assumption. |
static AbstractThrowableAssert<?,? extends Throwable> |
Assumptions.assumeThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)
Allows to capture and then assume on a
Throwable (easier done with lambdas). |
default AbstractThrowableAssert<?,? extends Throwable> |
WithAssumptions.assumeThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)
Allows to capture and then assume on a
Throwable (easier done with lambdas). |
static AbstractThrowableAssert<?,? extends Throwable> |
Assumptions.assumeThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Allows to capture and then assume on a
Throwable (easier done with lambdas). |
SELF |
AbstractIterableAssert.describedAs(Description description) |
ThrowableAssertAlternative<T> |
ThrowableAssertAlternative.describedAs(Description description)
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 |
AbstractListAssert.describedAs(Description description) |
SELF |
AbstractMapAssert.describedAs(Description description) |
ThrowableTypeAssert<T> |
ThrowableTypeAssert.describedAs(Description description)
Sets the description of the assertion that is going to be called after.
|
SELF |
AbstractIterableAssert.describedAs(String description,
Object... args) |
ThrowableAssertAlternative<T> |
ThrowableAssertAlternative.describedAs(String description,
Object... args)
Sets the description of the assertion that is going to be called after.
|
SELF |
AbstractAssert.describedAs(String description,
Object... args)
Sets the description of the assertion that is going to be called after.
|
SELF |
AbstractListAssert.describedAs(String description,
Object... args) |
SELF |
AbstractMapAssert.describedAs(String description,
Object... args) |
ThrowableTypeAssert<T> |
ThrowableTypeAssert.describedAs(String description,
Object... args)
Sets the description of the assertion that is going to be called after.
|
ELEMENT_ASSERT |
AbstractIterableAssert.element(int index)
Navigate and allow to perform assertions on the chosen element of the
Iterable 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.
|
<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.
|
<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.
|
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. |
ListAssert<Tuple> |
AbstractIterableAssert.extracting(Function<ELEMENT,?>... extractors)
|
ObjectArrayAssert<Tuple> |
AbstractObjectArrayAssert.extracting(Function<ELEMENT,?>... extractors)
|
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.
|
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.
|
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.
|
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.
|
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> |
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.
|
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.
|
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.
|
<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.
|
<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.
|
<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.
|
<V,EXCEPTION extends Exception> |
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.
|
<U,EXCEPTION extends Exception> |
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.
|
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.
|
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.
|
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> |
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.
|
<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.
|
<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.
|
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(Condition<? super ELEMENT> condition)
Filter the array under test keeping only elements matching the given
Condition . |
AtomicReferenceArrayAssert<T> |
AtomicReferenceArrayAssert.filteredOn(Condition<? super T> condition)
Filter the array under test keeping only elements matching the given
Condition . |
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. |
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. |
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. |
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. |
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. |
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. |
AtomicReferenceArrayAssert<T> |
AtomicReferenceArrayAssert.filteredOnNull(String propertyOrFieldName)
Filter the array under test keeping only elements whose property or field specified by
propertyOrFieldName
is null. |
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. |
ELEMENT_ASSERT |
AbstractIterableAssert.first()
Navigate and allow to perform assertions on the first element of the
Iterable 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.
|
<U,C extends Collection<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>> |
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.
|
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. |
AbstractObjectArrayAssert<?,Object> |
AbstractMapAssert.flatExtracting(String... keys)
Flatten the values of the given keys from the actual map under test into a new array, this new array becoming the 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.
|
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.
|
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.
|
<EXCEPTION extends Exception> |
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> |
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.
|
<U,C extends Collection<U>,EXCEPTION extends Exception> |
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.
|
<U,C extends Collection<U>,EXCEPTION extends Exception> |
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. |
AbstractObjectAssert<?,VALUE> |
AbstractOptionalAssert.get()
Verifies that the actual
Optional is not null and not empty and returns an Object assertion
that allows chaining (object) assertions on the optional value. |
AtomicReferenceArrayAssert<T> |
AtomicReferenceArrayAssert.inBinary() |
SELF |
AbstractIterableAssert.inBinary()
Enable binary representation of Iterable elements instead of standard representation in error messages.
|
SELF |
AbstractEnumerableAssert.inBinary() |
protected SELF |
AbstractAssert.inBinary()
Use binary object representation instead of standard representation in error messages.
|
SELF |
AbstractObjectArrayAssert.inBinary() |
SELF |
AbstractComparableAssert.inBinary() |
AtomicReferenceArrayAssert<T> |
AtomicReferenceArrayAssert.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 |
AbstractEnumerableAssert.inHexadecimal()
Enable hexadecimal object representation of Iterable elements instead of standard java representation in error messages.
|
protected SELF |
AbstractAssert.inHexadecimal()
Use hexadecimal object representation 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.
|
SELF |
AbstractComparableAssert.inHexadecimal() |
SELF |
AbstractCharSequenceAssert.inHexadecimal() |
SELF |
AbstractCharSequenceAssert.inUnicode()
Use unicode character representation instead of standard 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.
|
AtomicLongArrayAssert |
AtomicLongArrayAssert.isNotEmpty()
Verifies that the AtomicLongArray is not empty.
|
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 |
AbstractIterableAssert.overridingErrorMessage(String newErrorMessage,
Object... args) |
SELF |
AbstractAssert.overridingErrorMessage(String newErrorMessage,
Object... args)
Overrides AssertJ default error message by the given one.
|
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. |
static <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
Java6BDDAssertions.then(ACTUAL actual,
Class<ELEMENT_ASSERT> assertClass)
Creates a new instance of
allowing to navigate to any Iterable element
in order to perform assertions on it. |
static <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
BDDAssertions.then(ACTUAL actual,
Class<ELEMENT_ASSERT> assertClass)
Creates a new instance of
allowing to navigate to any Iterable element
in order to perform assertions on it. |
static <T> T |
Java6BDDAssertions.then(AssertProvider<T> component)
Delegates the creation of the
Assert to the AssertProvider.assertThat() of the given component. |
static <T> T |
BDDAssertions.then(AssertProvider<T> component)
Delegates the creation of the
Assert to the AssertProvider.assertThat() of the given component. |
static AtomicBooleanAssert |
Java6BDDAssertions.then(AtomicBoolean actual)
Create assertion for
AtomicBoolean . |
static AtomicBooleanAssert |
BDDAssertions.then(AtomicBoolean actual)
Create assertion for
AtomicBoolean . |
AtomicBooleanAssert |
Java6AbstractBDDSoftAssertions.then(AtomicBoolean actual)
Create assertion for
AtomicBoolean . |
static AtomicIntegerAssert |
Java6BDDAssertions.then(AtomicInteger actual)
Create assertion for
AtomicInteger . |
static AtomicIntegerAssert |
BDDAssertions.then(AtomicInteger actual)
Create assertion for
AtomicInteger . |
AtomicIntegerAssert |
Java6AbstractBDDSoftAssertions.then(AtomicInteger actual)
Create assertion for
AtomicInteger . |
static AtomicIntegerArrayAssert |
Java6BDDAssertions.then(AtomicIntegerArray actual)
Create int[] assertion for
AtomicIntegerArray . |
static AtomicIntegerArrayAssert |
BDDAssertions.then(AtomicIntegerArray actual)
Create assertion for
AtomicIntegerArray . |
AtomicIntegerArrayAssert |
Java6AbstractBDDSoftAssertions.then(AtomicIntegerArray actual)
Create assertion for
AtomicIntegerArray . |
static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT> |
Java6BDDAssertions.then(AtomicIntegerFieldUpdater<OBJECT> actual)
Create assertion for
AtomicIntegerFieldUpdater . |
static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT> |
BDDAssertions.then(AtomicIntegerFieldUpdater<OBJECT> actual)
Create assertion for
AtomicIntegerFieldUpdater . |
<OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT> |
Java6AbstractBDDSoftAssertions.then(AtomicIntegerFieldUpdater<OBJECT> actual)
Create assertion for
AtomicIntegerFieldUpdater . |
static AtomicLongAssert |
Java6BDDAssertions.then(AtomicLong actual)
Create assertion for
AtomicLong . |
static AtomicLongAssert |
BDDAssertions.then(AtomicLong actual)
Create assertion for
AtomicLong . |
AtomicLongAssert |
Java6AbstractBDDSoftAssertions.then(AtomicLong actual)
Create assertion for
AtomicLong . |
static AtomicLongArrayAssert |
Java6BDDAssertions.then(AtomicLongArray actual)
Create assertion for
AtomicLongArray . |
static AtomicLongArrayAssert |
BDDAssertions.then(AtomicLongArray actual)
Create assertion for
AtomicLongArray . |
AtomicLongArrayAssert |
Java6AbstractBDDSoftAssertions.then(AtomicLongArray actual)
Create assertion for
AtomicLongArray . |
static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT> |
Java6BDDAssertions.then(AtomicLongFieldUpdater<OBJECT> actual)
Create assertion for
AtomicLongFieldUpdater . |
static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT> |
BDDAssertions.then(AtomicLongFieldUpdater<OBJECT> actual)
Create assertion for
AtomicLongFieldUpdater . |
<OBJECT> AtomicLongFieldUpdaterAssert<OBJECT> |
Java6AbstractBDDSoftAssertions.then(AtomicLongFieldUpdater<OBJECT> actual)
Create assertion for
AtomicLongFieldUpdater . |
static <VALUE> AtomicMarkableReferenceAssert<VALUE> |
Java6BDDAssertions.then(AtomicMarkableReference<VALUE> actual)
Create assertion for
AtomicMarkableReference . |
static <VALUE> AtomicMarkableReferenceAssert<VALUE> |
BDDAssertions.then(AtomicMarkableReference<VALUE> actual)
Create assertion for
AtomicMarkableReference . |
<VALUE> AtomicMarkableReferenceAssert<VALUE> |
Java6AbstractBDDSoftAssertions.then(AtomicMarkableReference<VALUE> actual)
Create assertion for
AtomicMarkableReference . |
static <VALUE> AtomicReferenceAssert<VALUE> |
Java6BDDAssertions.then(AtomicReference<VALUE> actual)
Create assertion for
AtomicReference . |
static <VALUE> AtomicReferenceAssert<VALUE> |
BDDAssertions.then(AtomicReference<VALUE> actual)
Create assertion for
AtomicReference . |
<VALUE> AtomicReferenceAssert<VALUE> |
Java6AbstractBDDSoftAssertions.then(AtomicReference<VALUE> actual)
Create assertion for
AtomicReference . |
static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT> |
Java6BDDAssertions.then(AtomicReferenceArray<ELEMENT> actual)
Create assertion for
AtomicReferenceArray . |
static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT> |
BDDAssertions.then(AtomicReferenceArray<ELEMENT> actual)
Create assertion for
AtomicReferenceArray . |
<ELEMENT> AtomicReferenceArrayAssert<ELEMENT> |
Java6AbstractBDDSoftAssertions.then(AtomicReferenceArray<ELEMENT> actual)
Create assertion for
AtomicReferenceArray . |
static <FIELD,OBJECT> |
Java6BDDAssertions.then(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)
Create assertion for
AtomicReferenceFieldUpdater . |
static <FIELD,OBJECT> |
BDDAssertions.then(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)
Create assertion for
AtomicReferenceFieldUpdater . |
<FIELD,OBJECT> |
Java6AbstractBDDSoftAssertions.then(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)
Create assertion for
AtomicReferenceFieldUpdater . |
static <VALUE> AtomicStampedReferenceAssert<VALUE> |
Java6BDDAssertions.then(AtomicStampedReference<VALUE> actual)
Create assertion for
AtomicStampedReference . |
static <VALUE> AtomicStampedReferenceAssert<VALUE> |
BDDAssertions.then(AtomicStampedReference<VALUE> actual)
Create assertion for
AtomicStampedReference . |
<VALUE> AtomicStampedReferenceAssert<VALUE> |
Java6AbstractBDDSoftAssertions.then(AtomicStampedReference<VALUE> actual)
Create assertion for
AtomicStampedReference . |
static AbstractBigDecimalAssert<?> |
Java6BDDAssertions.then(BigDecimal actual)
Creates a new instance of
. |
static AbstractBigDecimalAssert<?> |
BDDAssertions.then(BigDecimal actual)
Creates a new instance of
. |
BigDecimalAssert |
Java6AbstractBDDSoftAssertions.then(BigDecimal actual)
Creates a new instance of
. |
static AbstractBigIntegerAssert<?> |
Java6BDDAssertions.then(BigInteger actual)
Creates a new instance of
. |
static AbstractBigIntegerAssert<?> |
BDDAssertions.then(BigInteger actual)
Creates a new instance of
. |
BigIntegerAssert |
Java6AbstractBDDSoftAssertions.then(BigInteger actual)
Creates a new instance of
. |
static AbstractBooleanAssert<?> |
Java6BDDAssertions.then(boolean actual)
Creates a new instance of
. |
static AbstractBooleanAssert<?> |
BDDAssertions.then(boolean actual)
Creates a new instance of
. |
BooleanAssert |
Java6AbstractBDDSoftAssertions.then(boolean actual)
Creates a new instance of
. |
static AbstractBooleanAssert<?> |
Java6BDDAssertions.then(Boolean actual)
Creates a new instance of
. |
static AbstractBooleanAssert<?> |
BDDAssertions.then(Boolean actual)
Creates a new instance of
. |
BooleanAssert |
Java6AbstractBDDSoftAssertions.then(Boolean actual)
Creates a new instance of
. |
static AbstractBooleanArrayAssert<?> |
Java6BDDAssertions.then(boolean[] actual)
Creates a new instance of
. |
static AbstractBooleanArrayAssert<?> |
BDDAssertions.then(boolean[] actual)
Creates a new instance of
. |
BooleanArrayAssert |
Java6AbstractBDDSoftAssertions.then(boolean[] actual)
Creates a new instance of
. |
static AbstractByteAssert<?> |
Java6BDDAssertions.then(byte actual)
Creates a new instance of
. |
static AbstractByteAssert<?> |
BDDAssertions.then(byte actual)
Creates a new instance of
. |
ByteAssert |
Java6AbstractBDDSoftAssertions.then(byte actual)
Creates a new instance of
. |
static AbstractByteAssert<?> |
Java6BDDAssertions.then(Byte actual)
Creates a new instance of
. |
static AbstractByteAssert<?> |
BDDAssertions.then(Byte actual)
Creates a new instance of
. |
ByteAssert |
Java6AbstractBDDSoftAssertions.then(Byte actual)
Creates a new instance of
. |
static AbstractByteArrayAssert<?> |
Java6BDDAssertions.then(byte[] actual)
Creates a new instance of
. |
static AbstractByteArrayAssert<?> |
BDDAssertions.then(byte[] actual)
Creates a new instance of
. |
ByteArrayAssert |
Java6AbstractBDDSoftAssertions.then(byte[] actual)
Creates a new instance of
. |
static AbstractCharacterAssert<?> |
Java6BDDAssertions.then(char actual)
Creates a new instance of
. |
static AbstractCharacterAssert<?> |
BDDAssertions.then(char actual)
Creates a new instance of
. |
CharacterAssert |
Java6AbstractBDDSoftAssertions.then(char actual)
Creates a new instance of
. |
static AbstractCharArrayAssert<?> |
Java6BDDAssertions.then(char[] actual)
Creates a new instance of
. |
static AbstractCharArrayAssert<?> |
BDDAssertions.then(char[] actual)
Creates a new instance of
. |
CharArrayAssert |
Java6AbstractBDDSoftAssertions.then(char[] actual)
Creates a new instance of
. |
static AbstractCharacterAssert<?> |
Java6BDDAssertions.then(Character actual)
Creates a new instance of
. |
static AbstractCharacterAssert<?> |
BDDAssertions.then(Character actual)
Creates a new instance of
. |
CharacterAssert |
Java6AbstractBDDSoftAssertions.then(Character actual)
Creates a new instance of
. |
static AbstractCharSequenceAssert<?,? extends CharSequence> |
Java6BDDAssertions.then(CharSequence actual)
Creates a new instance of
. |
static AbstractCharSequenceAssert<?,? extends CharSequence> |
BDDAssertions.then(CharSequence actual)
Creates a new instance of
. |
CharSequenceAssert |
Java6AbstractBDDSoftAssertions.then(CharSequence actual)
Creates a new instance of
. |
static AbstractClassAssert<?> |
Java6BDDAssertions.then(Class<?> actual)
Creates a new instance of
|
static AbstractClassAssert<?> |
BDDAssertions.then(Class<?> actual)
Creates a new instance of
|
SoftAssertionClassAssert |
Java6AbstractBDDSoftAssertions.then(Class<?> actual)
Creates a new instance of
|
<RESULT> CompletableFutureAssert<RESULT> |
AbstractBDDSoftAssertions.then(CompletableFuture<RESULT> actual)
Create assertion for
CompletableFuture . |
static <RESULT> CompletableFutureAssert<RESULT> |
BDDAssertions.then(CompletableFuture<RESULT> future)
Create assertion for
CompletableFuture . |
<RESULT> CompletableFutureAssert<RESULT> |
AbstractBDDSoftAssertions.then(CompletionStage<RESULT> actual)
Create assertion for
CompletionStage by converting it to a CompletableFuture and returning a CompletableFutureAssert . |
static <RESULT> CompletableFutureAssert<RESULT> |
BDDAssertions.then(CompletionStage<RESULT> actual)
Create assertion for
CompletionStage by converting it to a CompletableFuture and returning a CompletableFutureAssert . |
static AbstractDateAssert<?> |
Java6BDDAssertions.then(Date actual)
Creates a new instance of
. |
static AbstractDateAssert<?> |
BDDAssertions.then(Date actual)
Creates a new instance of
. |
DateAssert |
Java6AbstractBDDSoftAssertions.then(Date actual)
Creates a new instance of
. |
static AbstractDoubleAssert<?> |
Java6BDDAssertions.then(double actual)
Creates a new instance of
. |
static AbstractDoubleAssert<?> |
BDDAssertions.then(double actual)
Creates a new instance of
. |
DoubleAssert |
Java6AbstractBDDSoftAssertions.then(double actual)
Creates a new instance of
. |
static AbstractDoubleAssert<?> |
Java6BDDAssertions.then(Double actual)
Creates a new instance of
. |
static AbstractDoubleAssert<?> |
BDDAssertions.then(Double actual)
Creates a new instance of
. |
DoubleAssert |
Java6AbstractBDDSoftAssertions.then(Double actual)
Creates a new instance of
. |
static AbstractDoubleArrayAssert<?> |
Java6BDDAssertions.then(double[] actual)
Creates a new instance of
. |
static AbstractDoubleArrayAssert<?> |
BDDAssertions.then(double[] actual)
Creates a new instance of
. |
DoubleArrayAssert |
Java6AbstractBDDSoftAssertions.then(double[] actual)
Creates a new instance of
. |
DoublePredicateAssert |
AbstractBDDSoftAssertions.then(DoublePredicate actual)
Create assertion for
DoublePredicate . |
static DoublePredicateAssert |
BDDAssertions.then(DoublePredicate actual)
Create assertion for
DoublePredicate . |
AbstractListAssert<?,List<? extends Double>,Double,ObjectAssert<Double>> |
AbstractBDDSoftAssertions.then(DoubleStream actual)
Creates a new instance of
from the given DoubleStream . |
static AbstractListAssert<?,List<? extends Double>,Double,ObjectAssert<Double>> |
BDDAssertions.then(DoubleStream actual)
Creates a new instance of
from the given DoubleStream . |
static AbstractFileAssert<?> |
Java6BDDAssertions.then(File actual)
Creates a new instance of
. |
static AbstractFileAssert<?> |
BDDAssertions.then(File actual)
Creates a new instance of
. |
FileAssert |
Java6AbstractBDDSoftAssertions.then(File actual)
Creates a new instance of
. |
static AbstractFloatAssert<?> |
Java6BDDAssertions.then(float actual)
Creates a new instance of
. |
static AbstractFloatAssert<?> |
BDDAssertions.then(float actual)
Creates a new instance of
. |
FloatAssert |
Java6AbstractBDDSoftAssertions.then(float actual)
Creates a new instance of
. |
static AbstractFloatAssert<?> |
Java6BDDAssertions.then(Float actual)
Creates a new instance of
. |
static AbstractFloatAssert<?> |
BDDAssertions.then(Float actual)
Creates a new instance of
. |
FloatAssert |
Java6AbstractBDDSoftAssertions.then(Float actual)
Creates a new instance of
. |
static AbstractFloatArrayAssert<?> |
Java6BDDAssertions.then(float[] actual)
Creates a new instance of
. |
static AbstractFloatArrayAssert<?> |
BDDAssertions.then(float[] actual)
Creates a new instance of
. |
FloatArrayAssert |
Java6AbstractBDDSoftAssertions.then(float[] actual)
Creates a new instance of
. |
static <RESULT> AbstractFutureAssert<?,? extends Future<? extends RESULT>,RESULT> |
Java6BDDAssertions.then(Future<RESULT> actual)
Creates a new instance of
. |
static <RESULT> FutureAssert<RESULT> |
BDDAssertions.then(Future<RESULT> actual)
Creates a new instance of
FutureAssert |
<RESULT> FutureAssert<RESULT> |
Java6AbstractBDDSoftAssertions.then(Future<RESULT> actual)
Creates a new instance of
. |
static AbstractInputStreamAssert<?,? extends InputStream> |
Java6BDDAssertions.then(InputStream actual)
Creates a new instance of
. |
static AbstractInputStreamAssert<?,? extends InputStream> |
BDDAssertions.then(InputStream actual)
Creates a new instance of
. |
InputStreamAssert |
Java6AbstractBDDSoftAssertions.then(InputStream actual)
Creates a new instance of
. |
InstantAssert |
AbstractBDDSoftAssertions.then(Instant actual)
Creates a new instance of
. |
static AbstractInstantAssert<?> |
BDDAssertions.then(Instant actual)
Creates a new instance of
. |
static AbstractIntegerAssert<?> |
Java6BDDAssertions.then(int actual)
Creates a new instance of
. |
static AbstractIntegerAssert<?> |
BDDAssertions.then(int actual)
Creates a new instance of
. |
IntegerAssert |
Java6AbstractBDDSoftAssertions.then(int actual)
Creates a new instance of
. |
static AbstractIntArrayAssert<?> |
Java6BDDAssertions.then(int[] actual)
Creates a new instance of
. |
static AbstractIntArrayAssert<?> |
BDDAssertions.then(int[] actual)
Creates a new instance of
. |
IntArrayAssert |
Java6AbstractBDDSoftAssertions.then(int[] actual)
Creates a new instance of
. |
static AbstractIntegerAssert<?> |
Java6BDDAssertions.then(Integer actual)
Creates a new instance of
. |
static AbstractIntegerAssert<?> |
BDDAssertions.then(Integer actual)
Creates a new instance of
. |
IntegerAssert |
Java6AbstractBDDSoftAssertions.then(Integer actual)
Creates a new instance of
. |
IntPredicateAssert |
AbstractBDDSoftAssertions.then(IntPredicate actual)
Create assertion for
IntPredicate . |
static IntPredicateAssert |
BDDAssertions.then(IntPredicate actual)
Create assertion for
IntPredicate . |
AbstractListAssert<?,List<? extends Integer>,Integer,ObjectAssert<Integer>> |
AbstractBDDSoftAssertions.then(IntStream actual)
Creates a new instance of
from the given IntStream . |
static AbstractListAssert<?,List<? extends Integer>,Integer,ObjectAssert<Integer>> |
BDDAssertions.then(IntStream actual)
Creates a new instance of
from the given IntStream . |
static <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
Java6BDDAssertions.then(Iterable<? extends ELEMENT> actual,
AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
Creates a new instance of
allowing to navigate to any Iterable element
in order to perform assertions on it. |
static <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
BDDAssertions.then(Iterable<? extends ELEMENT> actual,
AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
Creates a new instance of
allowing to navigate to any Iterable element
in order to perform assertions on it. |
static <T> AbstractIterableAssert<?,Iterable<? extends T>,T,ObjectAssert<T>> |
Java6BDDAssertions.then(Iterable<? extends T> actual)
Creates a new instance of
. |
static <T> IterableAssert<T> |
BDDAssertions.then(Iterable<? extends T> actual)
Creates a new instance of
. |
<T> SoftAssertionIterableAssert<T> |
Java6AbstractBDDSoftAssertions.then(Iterable<? extends T> actual)
Creates a new instance of
. |
static <T> AbstractIterableAssert<?,Iterable<? extends T>,T,ObjectAssert<T>> |
Java6BDDAssertions.then(Iterator<? extends T> actual)
Creates a new instance of
. |
static <T> IterableAssert<T> |
BDDAssertions.then(Iterator<? extends T> actual)
Creates a new instance of
. |
<T> SoftAssertionIterableAssert<T> |
Java6AbstractBDDSoftAssertions.then(Iterator<? extends T> actual)
Creates a new instance of
. |
static <ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
Java6BDDAssertions.then(List<? extends ELEMENT> actual,
AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
Creates a new instance of
allowing to navigate to any List element
in order to perform assertions on it. |
static <ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
BDDAssertions.then(List<? extends ELEMENT> actual,
AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
Creates a new instance of
allowing to navigate to any List element
in order to perform assertions on it. |
static <ELEMENT,ACTUAL extends List<? extends ELEMENT>,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
Java6BDDAssertions.then(List<? extends ELEMENT> actual,
Class<ELEMENT_ASSERT> assertClass)
Creates a new instance of
allowing to navigate to any List element
in order to perform assertions on it. |
static <ELEMENT,ACTUAL extends List<? extends ELEMENT>,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
BDDAssertions.then(List<? extends ELEMENT> actual,
Class<ELEMENT_ASSERT> assertClass)
Creates a new instance of
tallowing to navigate to any List element
in order to perform assertions on it. |
static <T> AbstractListAssert<?,List<? extends T>,T,ObjectAssert<T>> |
Java6BDDAssertions.then(List<? extends T> actual)
Creates a new instance of
. |
static <T> ListAssert<T> |
BDDAssertions.then(List<? extends T> actual)
Creates a new instance of
. |
<T> SoftAssertionListAssert<T> |
Java6AbstractBDDSoftAssertions.then(List<? extends T> actual)
Creates a new instance of
. |
LocalDateAssert |
AbstractBDDSoftAssertions.then(LocalDate actual)
Creates a new instance of
. |
static AbstractLocalDateAssert<?> |
BDDAssertions.then(LocalDate actual)
Creates a new instance of
. |
LocalDateTimeAssert |
AbstractBDDSoftAssertions.then(LocalDateTime actual)
Creates a new instance of
. |
static AbstractLocalDateTimeAssert<?> |
BDDAssertions.then(LocalDateTime actual)
Creates a new instance of
. |
LocalTimeAssert |
AbstractBDDSoftAssertions.then(LocalTime actual)
Creates a new instance of
. |
static AbstractLocalTimeAssert<?> |
BDDAssertions.then(LocalTime actual)
Creates a new instance of
. |
static AbstractLongAssert<?> |
Java6BDDAssertions.then(long actual)
Creates a new instance of
. |
static AbstractLongAssert<?> |
BDDAssertions.then(long actual)
Creates a new instance of
. |
LongAssert |
Java6AbstractBDDSoftAssertions.then(long actual)
Creates a new instance of
. |
static AbstractLongAssert<?> |
Java6BDDAssertions.then(Long actual)
Creates a new instance of
. |
static AbstractLongAssert<?> |
BDDAssertions.then(Long actual)
Creates a new instance of
. |
LongAssert |
Java6AbstractBDDSoftAssertions.then(Long actual)
Creates a new instance of
. |
static AbstractLongArrayAssert<?> |
Java6BDDAssertions.then(long[] actual)
Creates a new instance of
. |
static AbstractLongArrayAssert<?> |
BDDAssertions.then(long[] actual)
Creates a new instance of
. |
LongArrayAssert |
Java6AbstractBDDSoftAssertions.then(long[] actual)
Creates a new instance of
. |
LongPredicateAssert |
AbstractBDDSoftAssertions.then(LongPredicate actual)
Create assertion for
DoublePredicate . |
static LongPredicateAssert |
BDDAssertions.then(LongPredicate actual)
Create assertion for
LongPredicate . |
AbstractListAssert<?,List<? extends Long>,Long,ObjectAssert<Long>> |
AbstractBDDSoftAssertions.then(LongStream actual)
Creates a new instance of
from the given LongStream . |
static AbstractListAssert<?,List<? extends Long>,Long,ObjectAssert<Long>> |
BDDAssertions.then(LongStream actual)
Creates a new instance of
from the given LongStream . |
static <K,V> MapAssert<K,V> |
Java6BDDAssertions.then(Map<K,V> actual)
Creates a new instance of
. |
static <K,V> MapAssert<K,V> |
BDDAssertions.then(Map<K,V> actual)
Creates a new instance of
. |
<K,V> SoftAssertionMapAssert<K,V> |
Java6AbstractBDDSoftAssertions.then(Map<K,V> actual)
Creates a new instance of
. |
OffsetDateTimeAssert |
AbstractBDDSoftAssertions.then(OffsetDateTime actual)
Creates a new instance of
. |
static AbstractOffsetDateTimeAssert<?> |
BDDAssertions.then(OffsetDateTime actual)
Creates a new instance of
. |
OffsetTimeAssert |
AbstractBDDSoftAssertions.then(OffsetTime actual)
Creates a new instance of
. |
static AbstractOffsetTimeAssert<?> |
BDDAssertions.then(OffsetTime actual)
Creates a new instance of
. |
<VALUE> OptionalAssert<VALUE> |
AbstractBDDSoftAssertions.then(Optional<VALUE> actual)
Create assertion for
Optional . |
static <VALUE> OptionalAssert<VALUE> |
BDDAssertions.then(Optional<VALUE> optional)
Create assertion for
Optional . |
OptionalDoubleAssert |
AbstractBDDSoftAssertions.then(OptionalDouble actual)
Create assertion for
OptionalDouble . |
static OptionalDoubleAssert |
BDDAssertions.then(OptionalDouble optional)
Create assertion for
OptionalDouble . |
OptionalIntAssert |
AbstractBDDSoftAssertions.then(OptionalInt actual)
Create assertion for
OptionalInt . |
static OptionalIntAssert |
BDDAssertions.then(OptionalInt optional)
Create assertion for
OptionalInt . |
OptionalLongAssert |
AbstractBDDSoftAssertions.then(OptionalLong actual)
Create assertion for
OptionalLong . |
static OptionalLongAssert |
BDDAssertions.then(OptionalLong optional)
Create assertion for
OptionalLong . |
PathAssert |
AbstractBDDSoftAssertions.then(Path actual)
Creates a new, proxied instance of a
PathAssert |
static AbstractPathAssert<?> |
BDDAssertions.then(Path actual)
Creates a new instance of
PathAssert |
<T> SoftAssertionPredicateAssert<T> |
AbstractBDDSoftAssertions.then(Predicate<T> actual)
Create assertion for
Predicate . |
static <T> PredicateAssert<T> |
BDDAssertions.then(Predicate<T> actual)
Create assertion for
Predicate . |
static AbstractShortAssert<?> |
Java6BDDAssertions.then(short actual)
Creates a new instance of
. |
static AbstractShortAssert<?> |
BDDAssertions.then(short actual)
Creates a new instance of
. |
ShortAssert |
Java6AbstractBDDSoftAssertions.then(short actual)
Creates a new instance of
. |
static AbstractShortAssert<?> |
Java6BDDAssertions.then(Short actual)
Creates a new instance of
. |
static AbstractShortAssert<?> |
BDDAssertions.then(Short actual)
Creates a new instance of
. |
ShortAssert |
Java6AbstractBDDSoftAssertions.then(Short actual)
Creates a new instance of
. |
static AbstractShortArrayAssert<?> |
Java6BDDAssertions.then(short[] actual)
Creates a new instance of
. |
static AbstractShortArrayAssert<?> |
BDDAssertions.then(short[] actual)
Creates a new instance of
. |
ShortArrayAssert |
Java6AbstractBDDSoftAssertions.then(short[] actual)
Creates a new instance of
. |
<ELEMENT> AbstractListAssert<?,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>> |
AbstractBDDSoftAssertions.then(Stream<? extends ELEMENT> actual)
Creates a new instance of
from the given Stream . |
static <ELEMENT> AbstractListAssert<?,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>> |
BDDAssertions.then(Stream<? extends ELEMENT> actual)
Creates a new instance of
from the given Stream . |
static AbstractCharSequenceAssert<?,String> |
Java6BDDAssertions.then(String actual)
Creates a new instance of
. |
static AbstractCharSequenceAssert<?,String> |
BDDAssertions.then(String actual)
Creates a new instance of
. |
StringAssert |
Java6AbstractBDDSoftAssertions.then(String actual)
Creates a new instance of
. |
static <T> AbstractObjectAssert<?,T> |
Java6BDDAssertions.then(T actual)
Creates a new instance of
. |
static <T> AbstractObjectAssert<?,T> |
BDDAssertions.then(T actual)
Creates a new instance of
. |
<T> ObjectAssert<T> |
Java6AbstractBDDSoftAssertions.then(T actual)
Creates a new instance of
. |
static <T extends Comparable<? super T>> |
Java6BDDAssertions.then(T actual)
Creates a new instance of
with
standard comparison semantics. |
static <T extends Comparable<? super T>> |
BDDAssertions.then(T actual)
Creates a new instance of
with
standard comparison semantics. |
<T extends Comparable<? super T>> |
Java6AbstractBDDSoftAssertions.then(T actual)
Creates a new instance of
with
standard comparison semantics. |
static <T extends AssertDelegateTarget> |
Java6BDDAssertions.then(T assertion)
Returns the given assertion.
|
static <T extends AssertDelegateTarget> |
BDDAssertions.then(T assertion)
Returns the given assertion.
|
static <T> AbstractObjectArrayAssert<?,T> |
Java6BDDAssertions.then(T[] actual)
Creates a new instance of
. |
static <T> AbstractObjectArrayAssert<?,T> |
BDDAssertions.then(T[] actual)
Creates a new instance of
. |
<T> ObjectArrayAssert<T> |
Java6AbstractBDDSoftAssertions.then(T[] actual)
Creates a new instance of
. |
static AbstractThrowableAssert<?,? extends Throwable> |
Java6BDDAssertions.then(Throwable actual)
Creates a new instance of
. |
static AbstractThrowableAssert<?,? extends Throwable> |
BDDAssertions.then(Throwable actual)
Creates a new instance of
. |
ThrowableAssert |
Java6AbstractBDDSoftAssertions.then(Throwable actual)
Creates a new instance of
. |
static AbstractUriAssert<?> |
Java6BDDAssertions.then(URI actual)
Creates a new instance of
. |
static AbstractUriAssert<?> |
BDDAssertions.then(URI actual)
Creates a new instance of
. |
UriAssert |
Java6AbstractBDDSoftAssertions.then(URI actual)
Creates a new instance of
. |
static AbstractUrlAssert<?> |
Java6BDDAssertions.then(URL actual)
Creates a new instance of
. |
static AbstractUrlAssert<?> |
BDDAssertions.then(URL actual)
Creates a new instance of
. |
AbstractUrlAssert<?> |
Java6AbstractBDDSoftAssertions.then(URL actual)
Creates a new instance of
. |
ZonedDateTimeAssert |
AbstractBDDSoftAssertions.then(ZonedDateTime actual)
Creates a new instance of
. |
static AbstractZonedDateTimeAssert<?> |
BDDAssertions.then(ZonedDateTime actual)
Creates a new instance of
. |
AbstractThrowableAssert<?,? extends Throwable> |
Java6BDDAssertions.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.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> |
Java6BDDAssertions.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> |
BDDAssertions.thenThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Allows to capture and then assert on a
Throwable (easier done with 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. |
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 |
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 |
AbstractFileAssert.usingCharset(String charsetName)
Specifies the name of the charset to use for text-based assertions on the file's contents.
|
SELF |
AbstractIterableAssert.usingComparator(Comparator<? super ACTUAL> customComparator) |
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 |
AbstractListAssert.usingComparator(Comparator<? super ACTUAL> customComparator) |
SELF |
AbstractMapAssert.usingComparator(Comparator<? super ACTUAL> customComparator) |
SELF |
AbstractComparableAssert.usingComparator(Comparator<? super ACTUAL> customComparator) |
SELF |
AbstractCharSequenceAssert.usingComparator(Comparator<? super ACTUAL> customComparator) |
AtomicIntegerAssert |
AtomicIntegerAssert.usingComparator(Comparator<? super AtomicInteger> customComparator) |
AtomicLongAssert |
AtomicLongAssert.usingComparator(Comparator<? super AtomicLong> customComparator) |
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 |
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 |
AbstractLongAssert.usingComparator(Comparator<? super Long> customComparator) |
SELF |
AbstractShortAssert.usingComparator(Comparator<? super Short> customComparator) |
<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.
|
<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.
|
<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> 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.
|
<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.
|
<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.
|
<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<? super T> comparator,
Class<T> type)
Allows to set a specific comparator to compare properties or fields with the given type.
|
<C> AtomicReferenceArrayAssert<T> |
AtomicReferenceArrayAssert.usingComparatorForType(Comparator<C> comparator,
Class<C> type)
Allows to set a specific comparator for the given type of elements or their fields.
|
<C> SELF |
AbstractObjectArrayAssert.usingComparatorForType(Comparator<C> comparator,
Class<C> type)
Allows to set a specific comparator for the given type of elements or their fields.
|
<T> SELF |
AbstractIterableAssert.usingComparatorForType(Comparator<T> comparator,
Class<T> type)
Allows to set a specific comparator for the given type of elements or their fields.
|
SELF |
AbstractDoubleArrayAssert.usingComparatorWithPrecision(Double precision)
Create a
Double comparator which compares double at the given precision and pass it to AbstractDoubleArrayAssert.usingElementComparator(Comparator) . |
SELF |
AbstractFloatArrayAssert.usingComparatorWithPrecision(Float precision)
Create a
Float comparator which compares floats at the given precision and pass it to AbstractFloatArrayAssert.usingElementComparator(Comparator) . |
SELF |
AbstractIterableAssert.usingDefaultComparator() |
SELF |
AbstractDateAssert.usingDefaultComparator() |
SELF |
AbstractIntegerAssert.usingDefaultComparator() |
AtomicLongAssert |
AtomicLongAssert.usingDefaultComparator() |
SELF |
AbstractFloatAssert.usingDefaultComparator() |
SELF |
AbstractShortAssert.usingDefaultComparator() |
SELF |
AbstractBigIntegerAssert.usingDefaultComparator() |
SELF |
AbstractDoubleAssert.usingDefaultComparator() |
SELF |
AbstractAssert.usingDefaultComparator()
Revert to standard comparison for incoming assertion checks.
|
SELF |
AbstractListAssert.usingDefaultComparator() |
SELF |
AbstractBigDecimalAssert.usingDefaultComparator() |
SELF |
AbstractMapAssert.usingDefaultComparator() |
SELF |
AbstractComparableAssert.usingDefaultComparator() |
SELF |
AbstractLongAssert.usingDefaultComparator() |
SELF |
AbstractCharSequenceAssert.usingDefaultComparator() |
SELF |
AbstractByteAssert.usingDefaultComparator() |
SELF |
AbstractCharacterAssert.usingDefaultComparator() |
AtomicIntegerAssert |
AtomicIntegerAssert.usingDefaultComparator() |
AtomicReferenceArrayAssert<T> |
AtomicReferenceArrayAssert.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 |
AbstractFloatArrayAssert.usingDefaultElementComparator()
Revert to standard comparison for incoming assertion group element checks.
|
SELF |
AbstractLongArrayAssert.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 |
AbstractByteArrayAssert.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 |
AbstractListAssert.usingDefaultElementComparator() |
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.
|
SELF |
AbstractDoubleArrayAssert.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 |
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 |
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 |
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 |
AbstractListAssert.usingElementComparator(Comparator<? super ELEMENT> customComparator) |
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. |
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. |
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. |
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. |
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. |
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. |
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.usingElementComparatorIgnoringFields(String... fields)
Use field/property by field/property comparison 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.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.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.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 |
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. |
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. |
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 |
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. |
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(DateFormat userCustomDateFormat)
Instead of using default date formats for the date String based Date assertions like
AbstractDateAssert.isEqualTo(String) ,
AssertJ is gonna use any date formats registered with one of these methods :
AbstractDateAssert.withDateFormat(String)
this method
AbstractDateAssert.registerCustomDateFormat(java.text.DateFormat)
AbstractDateAssert.registerCustomDateFormat(String)
|
SELF |
AbstractDateAssert.withDateFormat(String userCustomDateFormatPattern)
Instead of using default date formats for the date String based Date assertions like
AbstractDateAssert.isEqualTo(String) ,
AssertJ is gonna use any date formats registered with one of these methods :
this method
AbstractDateAssert.withDateFormat(java.text.DateFormat)
AbstractDateAssert.registerCustomDateFormat(java.text.DateFormat)
AbstractDateAssert.registerCustomDateFormat(String)
|
SELF |
AbstractDateAssert.withDefaultDateFormatsOnly()
Remove all registered custom date formats => use only the defaults date formats to parse string as date.
|
SELF |
AbstractIterableAssert.withFailMessage(String newErrorMessage,
Object... args) |
SELF |
AbstractAssert.withFailMessage(String newErrorMessage,
Object... args)
Alternative method for
AbstractAssert.overridingErrorMessage(java.lang.String, java.lang.Object...) |
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 |
AbstractIterableAssert.withThreadDumpOnError() |
SELF |
AbstractAssert.withThreadDumpOnError()
In case of an assertion error, a thread dump will be printed to
System.err . |
SELF |
AbstractListAssert.withThreadDumpOnError() |
SELF |
AbstractMapAssert.withThreadDumpOnError() |
Copyright © 2014–2018 AssertJ. All rights reserved.