java.lang.Object
- org.assertj.core.api.Assumptions

```
public class Assumptions
extends Object
```
Entry point for assumption methods for different types, which allow to skip test execution on failed assumptions.

Since:

2.9.0 / 3.9.0

Nested Class Summary

Nested Classes
Modifier and Type Class Description

private static class Assumptions.AssumptionMethodInterceptor

Field Summary

Fields
Modifier and Type	Field	Description
`private static net.bytebuddy.implementation.Implementation`	`ASSUMPTION`
`private static net.bytebuddy.ByteBuddy`	`BYTE_BUDDY`	This NamingStrategy takes the original class's name and adds a suffix to distinguish it.
`private static net.bytebuddy.TypeCache<net.bytebuddy.TypeCache.SimpleKey>`	`CACHE`

Constructor Summary

Constructors
Constructor Description

Assumptions()

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`private static <ASSERTION> ASSERTION`	`asAssumption(Class<ASSERTION> assertionType, Class<?>[] constructorTypes, Object... constructorParams)`
`private static <ASSERTION,ACTUAL> ASSERTION`	`asAssumption(Class<ASSERTION> assertionType, Class<ACTUAL> actualType, Object actual)`
`private static AbstractAssert<?,?>`	`asAssumption(AbstractAssert<?,?> assertion)`
`private static AbstractAssert<?,?>`	`asIterableSizeAssumption(AbstractAssert<?,?> assertion)`
`private static AbstractAssert<?,?>`	`asMapSizeAssumption(AbstractAssert<?,?> assertion)`
`private static AbstractAssert<?,?>`	`asRecursiveComparisonAssumption(AbstractAssert<?,?> assertion)`
`static BooleanAssert`	`assumeThat(boolean actual)`	Creates a new instance of `BooleanAssert` assumption.
`static BooleanArrayAssert`	`assumeThat(boolean[] actual)`	Creates a new instance of `BooleanArrayAssert` assumption.
`static Boolean2DArrayAssert`	`assumeThat(boolean[][] actual)`	Creates a new instance of `Boolean2DArrayAssert` assumption.
`static ByteAssert`	`assumeThat(byte actual)`	Creates a new instance of `ByteAssert` assumption.
`static ByteArrayAssert`	`assumeThat(byte[] actual)`	Creates a new instance of `ByteArrayAssert` assumption.
`static Byte2DArrayAssert`	`assumeThat(byte[][] actual)`	Creates a new instance of `Byte2DArrayAssert` assumption.
`static CharacterAssert`	`assumeThat(char actual)`	Creates a new instance of `CharacterAssert` assumption.
`static CharArrayAssert`	`assumeThat(char[] actual)`	Creates a new instance of `CharArrayAssert` assumption.
`static Char2DArrayAssert`	`assumeThat(char[][] actual)`	Creates a new instance of `Char2DArrayAssert` assumption.
`static DoubleAssert`	`assumeThat(double actual)`	Creates a new instance of `DoubleAssert` assumption.
`static DoubleArrayAssert`	`assumeThat(double[] actual)`	Creates a new instance of `DoubleArrayAssert` assumption.
`static Double2DArrayAssert`	`assumeThat(double[][] actual)`	Creates a new instance of `Double2DArrayAssert` assumption.
`static FloatAssert`	`assumeThat(float actual)`	Creates a new instance of `FloatAssert` assumption.
`static FloatArrayAssert`	`assumeThat(float[] actual)`	Creates a new instance of `FloatArrayAssert` assumption.
`static Float2DArrayAssert`	`assumeThat(float[][] actual)`	Creates a new instance of `Float2DArrayAssert` assumption.
`static IntegerAssert`	`assumeThat(int actual)`	Creates a new instance of `IntegerAssert` assumption.
`static IntArrayAssert`	`assumeThat(int[] actual)`	Creates a new instance of `IntArrayAssert` assumption.
`static Int2DArrayAssert`	`assumeThat(int[][] actual)`	Creates a new instance of `Int2DArrayAssert` assumption.
`static LongAssert`	`assumeThat(long actual)`	Creates a new instance of `LongAssert` assumption.
`static LongArrayAssert`	`assumeThat(long[] actual)`	Creates a new instance of `LongArrayAssert` assumption.
`static Long2DArrayAssert`	`assumeThat(long[][] actual)`	Creates a new instance of `Long2DArrayAssert` assumption.
`static ShortAssert`	`assumeThat(short actual)`	Creates a new instance of `ShortAssert` assumption.
`static ShortArrayAssert`	`assumeThat(short[] actual)`	Creates a new instance of `ShortArrayAssert` assumption.
`static Short2DArrayAssert`	`assumeThat(short[][] actual)`	Creates a new instance of `Short2DArrayAssert` assumption.
`static FileAssert`	`assumeThat(File actual)`	Creates a new instance of `FileAssert` assumption.
`static InputStreamAssert`	`assumeThat(InputStream actual)`	Creates a new instance of `InputStreamAssert` assumption.
`static BooleanAssert`	`assumeThat(Boolean actual)`	Creates a new instance of `BooleanAssert` assumption.
`static ByteAssert`	`assumeThat(Byte actual)`	Creates a new instance of `ByteAssert` assumption.
`static CharacterAssert`	`assumeThat(Character actual)`	Creates a new instance of `CharacterAssert` assumption.
`static CharSequenceAssert`	`assumeThat(CharSequence actual)`	Creates a new instance of `CharSequenceAssert` assumption.
`static ClassAssert`	`assumeThat(Class<?> actual)`	Creates a new instance of `ClassAssert` assumption.
`static DoubleAssert`	`assumeThat(Double actual)`	Creates a new instance of `DoubleAssert` assumption.
`static FloatAssert`	`assumeThat(Float actual)`	Creates a new instance of `FloatAssert` assumption.
`static IntegerAssert`	`assumeThat(Integer actual)`	Creates a new instance of `IntegerAssert` assumption.
`static <ELEMENT> IterableAssert<ELEMENT>`	`assumeThat(Iterable<? extends ELEMENT> actual)`	Creates a new instance of `IterableAssert` assumption.
`static LongAssert`	`assumeThat(Long actual)`	Creates a new instance of `LongAssert` assumption.
`static ShortAssert`	`assumeThat(Short actual)`	Creates a new instance of `ShortAssert` assumption.
`static StringAssert`	`assumeThat(String actual)`	Creates a new instance of `StringAssert` assumption.
`static CharSequenceAssert`	`assumeThat(StringBuffer actual)`	Creates a new instance of `CharSequenceAssert` assumption from a `StringBuffer`.
`static CharSequenceAssert`	`assumeThat(StringBuilder actual)`	Creates a new instance of `CharSequenceAssert` assumption from a `StringBuilder`.
`static ThrowableAssert`	`assumeThat(Throwable actual)`	Creates a new instance of `ThrowableAssert` assumption.
`static BigDecimalAssert`	`assumeThat(BigDecimal actual)`	Creates a new instance of `BigDecimalAssert` assumption.
`static BigIntegerAssert`	`assumeThat(BigInteger actual)`	Creates a new instance of `BigIntegerAssert` assumption.
`static UriAssert`	`assumeThat(URI actual)`	Creates a new instance of `UriAssert` assumption.
`static UrlAssert`	`assumeThat(URL actual)`	Creates a new instance of `UrlAssert` assumption.
`static PathAssert`	`assumeThat(Path actual)`	Creates a new instance of `PathAssert` assumption.
`static DurationAssert`	`assumeThat(Duration actual)`	Creates a new instance of `DurationAssert` assumption.
`static InstantAssert`	`assumeThat(Instant actual)`	Creates a new instance of `InstantAssert` assumption.
`static LocalDateAssert`	`assumeThat(LocalDate actual)`	Creates a new instance of `LocalDateAssert` assumption.
`static LocalDateTimeAssert`	`assumeThat(LocalDateTime actual)`	Creates a new instance of `LocalDateTimeAssert` assumption.
`static LocalTimeAssert`	`assumeThat(LocalTime actual)`	Creates a new instance of `LocalTimeAssert` assumption.
`static OffsetDateTimeAssert`	`assumeThat(OffsetDateTime actual)`	Creates a new instance of `OffsetDateTimeAssert` assumption.
`static OffsetTimeAssert`	`assumeThat(OffsetTime actual)`	Creates a new instance of `OffsetTimeAssert` assumption.
`static PeriodAssert`	`assumeThat(Period actual)`	Creates a new instance of `PeriodAssert` assumption.
`static ZonedDateTimeAssert`	`assumeThat(ZonedDateTime actual)`	Creates a new instance of `ZonedDateTimeAssert` assumption.
`static AtomicBooleanAssert`	`assumeThat(AtomicBoolean actual)`	Create assumption for `AtomicBoolean`.
`static AtomicIntegerAssert`	`assumeThat(AtomicInteger actual)`	Create assumption for `AtomicInteger`.
`static AtomicIntegerArrayAssert`	`assumeThat(AtomicIntegerArray actual)`	Creates int[] assumption for `AtomicIntegerArray`.
`static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT>`	`assumeThat(AtomicIntegerFieldUpdater<OBJECT> actual)`	Create assumption for `AtomicIntegerFieldUpdater`.
`static AtomicLongAssert`	`assumeThat(AtomicLong actual)`	Create assumption for `AtomicLong`.
`static AtomicLongArrayAssert`	`assumeThat(AtomicLongArray actual)`	Create assumption for `AtomicLongArray`.
`static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT>`	`assumeThat(AtomicLongFieldUpdater<OBJECT> actual)`	Create assumption for `AtomicLongFieldUpdater`.
`static <VALUE> AtomicMarkableReferenceAssert<VALUE>`	`assumeThat(AtomicMarkableReference<VALUE> actual)`	Create assumption for `AtomicMarkableReference`.
`static <VALUE> AtomicReferenceAssert<VALUE>`	`assumeThat(AtomicReference<VALUE> actual)`	Create assumption for `AtomicReference`.
`static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>`	`assumeThat(AtomicReferenceArray<ELEMENT> actual)`	Create assumption for `AtomicReferenceArray`.
`static <FIELD,OBJECT> AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT>`	`assumeThat(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)`	Create assumption for `AtomicReferenceFieldUpdater`.
`static <VALUE> AtomicStampedReferenceAssert<VALUE>`	`assumeThat(AtomicStampedReference<VALUE> actual)`	Create assumption for `AtomicStampedReference`.
`static LongAdderAssert`	`assumeThat(LongAdder actual)`	Create assumption for `LongAdder`.
`static <RESULT> CompletableFutureAssert<RESULT>`	`assumeThat(CompletableFuture<RESULT> actual)`	Creates a new instance of `CompletableFutureAssert` assumption.
`static <RESULT> CompletableFutureAssert<RESULT>`	`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 <RESULT> FutureAssert<RESULT>`	`assumeThat(Future<RESULT> future)`	Create assertion for `FutureAssert` assumption.
`static DateAssert`	`assumeThat(Date actual)`	Creates a new instance of `DateAssert` assumption.
`static DoublePredicateAssert`	`assumeThat(DoublePredicate actual)`	Creates a new instance of `DoublePredicateAssert` assumption.
`static IntPredicateAssert`	`assumeThat(IntPredicate actual)`	Creates a new instance of `IntPredicateAssert` assumption.
`static LongPredicateAssert`	`assumeThat(LongPredicate actual)`	Creates a new instance of `LongPredicateAssert` assumption.
`static <T> PredicateAssert<T>`	`assumeThat(Predicate<T> actual)`	Creates a new instance of `PredicateAssert` assumption.
`static <ELEMENT> IteratorAssert<ELEMENT>`	`assumeThat(Iterator<? extends ELEMENT> actual)`	Creates a new instance of `IteratorAssert` assumption.
`static <ELEMENT> ListAssert<ELEMENT>`	`assumeThat(List<? extends ELEMENT> actual)`	Creates a new instance of `ListAssert` assumption.
`static <K,V> MapAssert<K,V>`	`assumeThat(Map<K,V> actual)`	Creates a new instance of `MapAssert` assumption.
`static <VALUE> OptionalAssert<VALUE>`	`assumeThat(Optional<VALUE> actual)`	Creates a new instance of `OptionalAssert` assumption.
`static OptionalDoubleAssert`	`assumeThat(OptionalDouble actual)`	Creates a new instance of `OptionalDoubleAssert` assumption.
`static OptionalIntAssert`	`assumeThat(OptionalInt actual)`	Creates a new instance of `OptionalIntAssert` assumption.
`static OptionalLongAssert`	`assumeThat(OptionalLong actual)`	Creates a new instance of `OptionalLongAssert` assumption.
`static <ELEMENT> SpliteratorAssert<ELEMENT>`	`assumeThat(Spliterator<ELEMENT> actual)`	Creates a new instance of `SpliteratorAssert` assumption from the given `Spliterator`.
`static ListAssert<Double>`	`assumeThat(DoubleStream actual)`	Creates a new instance of `ListAssert` assumption from the given `DoubleStream`.
`static ListAssert<Integer>`	`assumeThat(IntStream actual)`	Creates a new instance of `ListAssert` assumption from the given `IntStream`.
`static ListAssert<Long>`	`assumeThat(LongStream actual)`	Creates a new instance of `ListAssert` assumption from the given `LongStream`.
`static <ELEMENT> ListAssert<ELEMENT>`	`assumeThat(Stream<? extends ELEMENT> actual)`	Creates a new instance of `ListAssert` assumption from the given `Stream`.
`static <T> ObjectAssert<T>`	`assumeThat(T actual)`	Creates a new instance of `ObjectAssert` assumption.
`static <T> ObjectArrayAssert<T>`	`assumeThat(T[] actual)`	Creates a new instance of `ObjectArrayAssert` assumption.
`static <T> Object2DArrayAssert<T>`	`assumeThat(T[][] actual)`	Creates a new instance of `Object2DArrayAssert` assumption.
`static ThrowableAssert`	`assumeThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)`	Allows to capture and then assume on a `Throwable` (easier done with lambdas).
`static <T> ObjectAssert<T>`	`assumeThatObject(T actual)`	Creates a new instance of `ObjectAssert` assumption.
`static ThrowableAssert`	`assumeThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)`	Allows to capture and then assume on a `Throwable` (easier done with lambdas).
`private static RuntimeException`	`assumptionNotMet(AssertionError assertionError)`
`private static RuntimeException`	`assumptionNotMet(Class<?> exceptionClass, AssertionError e)`
`private static <ASSERTION> Class<? extends ASSERTION>`	`createAssumptionClass(Class<ASSERTION> assertClass)`
`protected static <ASSERTION> Class<? extends ASSERTION>`	`generateAssumptionClass(Class<ASSERTION> assertionType)`
`private static Class<?>`	`getAssumptionClass(String className)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - BYTE_BUDDY
```
private static final net.bytebuddy.ByteBuddy BYTE_BUDDY
```
    This NamingStrategy takes the original class's name and adds a suffix to distinguish it. The default is ByteBuddy but for debugging purposes, it makes sense to add AssertJ as a name.
  - ASSUMPTION
```
private static final net.bytebuddy.implementation.Implementation ASSUMPTION
```
  - CACHE
```
private static final net.bytebuddy.TypeCache<net.bytebuddy.TypeCache.SimpleKey> CACHE
```
- Constructor Detail
  - Assumptions
```
public Assumptions()
```
- Method Detail
  - assumeThat
```
public static <T> ObjectAssert<T> assumeThat(T actual)
```
    Creates a new instance of ObjectAssert assumption.
    
    Type Parameters:
    
    T - the type of the actual value.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static StringAssert assumeThat(String actual)
```
    Creates a new instance of StringAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static BigDecimalAssert assumeThat(BigDecimal actual)
```
    Creates a new instance of BigDecimalAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static BigIntegerAssert assumeThat(BigInteger actual)
```
    Creates a new instance of BigIntegerAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static UriAssert assumeThat(URI actual)
```
    Creates a new instance of UriAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static UrlAssert assumeThat(URL actual)
```
    Creates a new instance of UrlAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static BooleanAssert assumeThat(boolean actual)
```
    Creates a new instance of BooleanAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static BooleanAssert assumeThat(Boolean actual)
```
    Creates a new instance of BooleanAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static BooleanArrayAssert assumeThat(boolean[] actual)
```
    Creates a new instance of BooleanArrayAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static Boolean2DArrayAssert assumeThat(boolean[][] actual)
```
    Creates a new instance of Boolean2DArrayAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.17.0
  - assumeThat
```
public static ByteAssert assumeThat(byte actual)
```
    Creates a new instance of ByteAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static ByteAssert assumeThat(Byte actual)
```
    Creates a new instance of ByteAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static ByteArrayAssert assumeThat(byte[] actual)
```
    Creates a new instance of ByteArrayAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static Byte2DArrayAssert assumeThat(byte[][] actual)
```
    Creates a new instance of Byte2DArrayAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.17.0
  - assumeThat
```
public static CharacterAssert assumeThat(char actual)
```
    Creates a new instance of CharacterAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static CharacterAssert assumeThat(Character actual)
```
    Creates a new instance of CharacterAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static CharArrayAssert assumeThat(char[] actual)
```
    Creates a new instance of CharArrayAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static Char2DArrayAssert assumeThat(char[][] actual)
```
    Creates a new instance of Char2DArrayAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.17.0
  - assumeThat
```
public static CharSequenceAssert assumeThat(CharSequence actual)
```
    Creates a new instance of CharSequenceAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static CharSequenceAssert assumeThat(StringBuilder actual)
```
    Creates a new instance of CharSequenceAssert assumption from a StringBuilder.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.11.0
  - assumeThat
```
public static CharSequenceAssert assumeThat(StringBuffer actual)
```
    Creates a new instance of CharSequenceAssert assumption from a StringBuffer.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.11.0
  - assumeThat
```
public static ShortAssert assumeThat(short actual)
```
    Creates a new instance of ShortAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static ShortAssert assumeThat(Short actual)
```
    Creates a new instance of ShortAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static ShortArrayAssert assumeThat(short[] actual)
```
    Creates a new instance of ShortArrayAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static Short2DArrayAssert assumeThat(short[][] actual)
```
    Creates a new instance of Short2DArrayAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.17.0
  - assumeThat
```
public static IntegerAssert assumeThat(int actual)
```
    Creates a new instance of IntegerAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static IntegerAssert assumeThat(Integer actual)
```
    Creates a new instance of IntegerAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static IntArrayAssert assumeThat(int[] actual)
```
    Creates a new instance of IntArrayAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static Int2DArrayAssert assumeThat(int[][] actual)
```
    Creates a new instance of Int2DArrayAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.17.0
  - assumeThat
```
public static LongAssert assumeThat(long actual)
```
    Creates a new instance of LongAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static LongAssert assumeThat(Long actual)
```
    Creates a new instance of LongAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static LongArrayAssert assumeThat(long[] actual)
```
    Creates a new instance of LongArrayAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static Long2DArrayAssert assumeThat(long[][] actual)
```
    Creates a new instance of Long2DArrayAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.17.0
  - assumeThat
```
public static FloatAssert assumeThat(float actual)
```
    Creates a new instance of FloatAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static FloatAssert assumeThat(Float actual)
```
    Creates a new instance of FloatAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static FloatArrayAssert assumeThat(float[] actual)
```
    Creates a new instance of FloatArrayAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static Float2DArrayAssert assumeThat(float[][] actual)
```
    Creates a new instance of Float2DArrayAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.17.0
  - assumeThat
```
public static DoubleAssert assumeThat(double actual)
```
    Creates a new instance of DoubleAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static DoubleAssert assumeThat(Double actual)
```
    Creates a new instance of DoubleAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static DoubleArrayAssert assumeThat(double[] actual)
```
    Creates a new instance of DoubleArrayAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static Double2DArrayAssert assumeThat(double[][] actual)
```
    Creates a new instance of Double2DArrayAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.17.0
  - assumeThat
```
public static AtomicBooleanAssert assumeThat(AtomicBoolean actual)
```
    Create assumption for AtomicBoolean.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static AtomicIntegerAssert assumeThat(AtomicInteger actual)
```
    Create assumption for AtomicInteger.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static AtomicIntegerArrayAssert assumeThat(AtomicIntegerArray actual)
```
    Creates int[] assumption for AtomicIntegerArray.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT> assumeThat(AtomicIntegerFieldUpdater<OBJECT> actual)
```
    Create assumption for AtomicIntegerFieldUpdater.
    
    Type Parameters:
    
    OBJECT - the type of the object holding the updatable field.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static LongAdderAssert assumeThat(LongAdder actual)
```
    Create assumption for LongAdder.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.16.0
  - assumeThat
```
public static AtomicLongAssert assumeThat(AtomicLong actual)
```
    Create assumption for AtomicLong.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static AtomicLongArrayAssert assumeThat(AtomicLongArray actual)
```
    Create assumption for AtomicLongArray.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT> assumeThat(AtomicLongFieldUpdater<OBJECT> actual)
```
    Create assumption for AtomicLongFieldUpdater.
    
    Type Parameters:
    
    OBJECT - the type of the object holding the updatable field.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static <VALUE> AtomicReferenceAssert<VALUE> assumeThat(AtomicReference<VALUE> actual)
```
    Create assumption for AtomicReference.
    
    Type Parameters:
    
    VALUE - the type of the value contained in the AtomicReference.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT> assumeThat(AtomicReferenceArray<ELEMENT> actual)
```
    Create assumption for AtomicReferenceArray.
    
    Type Parameters:
    
    ELEMENT - the type of the value contained in the AtomicReferenceArray.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static <FIELD,OBJECT> AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT> assumeThat(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)
```
    Create assumption for AtomicReferenceFieldUpdater.
    
    Type Parameters:
    
    FIELD - the type of the field which gets updated by the AtomicReferenceFieldUpdater.
    
    OBJECT - the type of the object holding the updatable field.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static <VALUE> AtomicMarkableReferenceAssert<VALUE> assumeThat(AtomicMarkableReference<VALUE> actual)
```
    Create assumption for AtomicMarkableReference.
    
    Type Parameters:
    
    VALUE - the type of the value contained in the AtomicMarkableReference.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static <VALUE> AtomicStampedReferenceAssert<VALUE> assumeThat(AtomicStampedReference<VALUE> actual)
```
    Create assumption for AtomicStampedReference.
    
    Type Parameters:
    
    VALUE - the type of the value contained in the AtomicStampedReference.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static ClassAssert assumeThat(Class<?> actual)
```
    Creates a new instance of ClassAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static DateAssert assumeThat(Date actual)
```
    Creates a new instance of DateAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static FileAssert assumeThat(File actual)
```
    Creates a new instance of FileAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static PathAssert assumeThat(Path actual)
```
    Creates a new instance of PathAssert assumption.
    
    Parameters:
    
    actual - the path to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static InputStreamAssert assumeThat(InputStream actual)
```
    Creates a new instance of InputStreamAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static <RESULT> FutureAssert<RESULT> assumeThat(Future<RESULT> future)
```
    Create assertion for FutureAssert assumption.
    
    Type Parameters:
    
    RESULT - the type of the value contained in the Future.
    
    Parameters:
    
    future - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static <ELEMENT> IterableAssert<ELEMENT> assumeThat(Iterable<? extends ELEMENT> actual)
```
    Creates a new instance of IterableAssert assumption.
    
    Type Parameters:
    
    ELEMENT - the type of elements.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static <ELEMENT> IteratorAssert<ELEMENT> assumeThat(Iterator<? extends ELEMENT> actual)
```
    Creates a new instance of IteratorAssert assumption.
    
    Type Parameters:
    
    ELEMENT - the type of elements.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static <ELEMENT> ListAssert<ELEMENT> assumeThat(List<? extends ELEMENT> actual)
```
    Creates a new instance of ListAssert assumption.
    
    Type Parameters:
    
    ELEMENT - the type of elements.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static <T> ObjectArrayAssert<T> assumeThat(T[] actual)
```
    Creates a new instance of ObjectArrayAssert assumption.
    
    Type Parameters:
    
    T - the type of elements.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static <T> Object2DArrayAssert<T> assumeThat(T[][] actual)
```
    Creates a new instance of Object2DArrayAssert assumption.
    
    Type Parameters:
    
    T - the type of elements.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.17.0
  - assumeThat
```
public static <K,V> MapAssert<K,V> assumeThat(Map<K,V> actual)
```
    Creates a new instance of MapAssert assumption.
    
    Type Parameters:
    
    K - the type of keys in the map.
    
    V - the type of values in the map.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static <T extends Comparable<? super T>> GenericComparableAssert<T> assumeThat(T actual)
```
    Creates a new instance of GenericComparableAssert assumption.
    
    Type Parameters:
    
    T - the type of actual.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThat
```
public static ThrowableAssert assumeThat(Throwable actual)
```
    Creates a new instance of ThrowableAssert assumption.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThatThrownBy
```
public static ThrowableAssert assumeThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
```
    Allows to capture and then assume on a Throwable (easier done with lambdas).
    Example :
    @Test public void testException() { assumeThatThrownBy(() -> { throw new Exception("boom!") }).isInstanceOf(Exception.class) .hasMessageContaining("boom"); }
    Parameters:
    
    shouldRaiseThrowable - The ThrowableAssert.ThrowingCallable or lambda with the code that should raise the throwable.
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    2.9.0 / 3.9.0
  - assumeThatCode
```
public static ThrowableAssert assumeThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)
```
    Allows to capture and then assume on a Throwable (easier done with lambdas).
    The main difference with assumeThatThrownBy(ThrowingCallable) is that this method does not fail if no exception was thrown.
    Example :
    ThrowingCallable callable = () -> { throw new Exception("boom!"); }; // assertion succeeds assumeThatCode(callable).isInstanceOf(Exception.class) .hasMessageContaining("boom"); // assertion fails assumeThatCode(callable).doesNotThrowAnyException();
    
    This method was not named assumeThat because the java compiler reported it ambiguous when used directly with a lambda :(
    Parameters:
    
    shouldRaiseOrNotThrowable - The ThrowableAssert.ThrowingCallable or lambda with the code that should raise the throwable.
    
    Returns:
    
    the created ThrowableAssert.
    
    Since:
    
    3.9.0
  - assumeThatObject
```
public static <T> ObjectAssert<T> assumeThatObject(T actual)
```
    Creates a new instance of ObjectAssert assumption.
    This overload is useful, when an overloaded method of assertThat(...) takes precedence over the generic assumeThat(Object).
    Example:
    Cast necessary because assumeThat(List) "forgets" actual type:
    assumeThat(new LinkedList<>(asList("abc"))).matches(list -> ((Deque<String>) list).getFirst().equals("abc"));
    No cast needed, but also no additional list assertions:
    assumeThatObject(new LinkedList<>(asList("abc"))).matches(list -> list.getFirst().equals("abc"));
    Type Parameters:
    
    T - the type of the actual value.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assertion object.
    
    Since:
    
    3.12.0
  - assumeThat
```
public static <T> PredicateAssert<T> assumeThat(Predicate<T> actual)
```
    Creates a new instance of PredicateAssert assumption.
    
    Type Parameters:
    
    T - the Predicate type.
    
    Parameters:
    
    actual - the Predicate to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static IntPredicateAssert assumeThat(IntPredicate actual)
```
    Creates a new instance of IntPredicateAssert assumption.
    
    Parameters:
    
    actual - the IntPredicate to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static LongPredicateAssert assumeThat(LongPredicate actual)
```
    Creates a new instance of LongPredicateAssert assumption.
    
    Parameters:
    
    actual - the LongPredicate to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static DoublePredicateAssert assumeThat(DoublePredicate actual)
```
    Creates a new instance of DoublePredicateAssert assumption.
    
    Parameters:
    
    actual - the DoublePredicate to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static <RESULT> CompletableFutureAssert<RESULT> assumeThat(CompletableFuture<RESULT> actual)
```
    Creates a new instance of CompletableFutureAssert assumption.
    
    Type Parameters:
    
    RESULT - the CompletableFuture wrapped type.
    
    Parameters:
    
    actual - the CompletableFuture to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static <RESULT> CompletableFutureAssert<RESULT> assumeThat(CompletionStage<RESULT> actual)
```
    Creates a new instance of CompletableFutureAssert assumption for a CompletionStage by converting it to a CompletableFuture and returning a CompletableFutureAssert.
    If the given CompletionStage is null, the CompletableFuture in the returned CompletableFutureAssert will also be null.
    
    Type Parameters:
    
    RESULT - the CompletableFuture wrapped type.
    
    Parameters:
    
    actual - the CompletableFuture to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static <VALUE> OptionalAssert<VALUE> assumeThat(Optional<VALUE> actual)
```
    Creates a new instance of OptionalAssert assumption.
    
    Type Parameters:
    
    VALUE - the Optional wrapped type.
    
    Parameters:
    
    actual - the Optional to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static OptionalDoubleAssert assumeThat(OptionalDouble actual)
```
    Creates a new instance of OptionalDoubleAssert assumption.
    
    Parameters:
    
    actual - the OptionalDouble to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static OptionalIntAssert assumeThat(OptionalInt actual)
```
    Creates a new instance of OptionalIntAssert assumption.
    
    Parameters:
    
    actual - the OptionalInt to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static OptionalLongAssert assumeThat(OptionalLong actual)
```
    Creates a new instance of OptionalLongAssert assumption.
    
    Parameters:
    
    actual - the OptionalLong to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static ZonedDateTimeAssert assumeThat(ZonedDateTime actual)
```
    Creates a new instance of ZonedDateTimeAssert assumption.
    
    Parameters:
    
    actual - the ZonedDateTime to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static LocalDateTimeAssert assumeThat(LocalDateTime actual)
```
    Creates a new instance of LocalDateTimeAssert assumption.
    
    Parameters:
    
    actual - the LocalDateTime to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static OffsetDateTimeAssert assumeThat(OffsetDateTime actual)
```
    Creates a new instance of OffsetDateTimeAssert assumption.
    
    Parameters:
    
    actual - the OffsetDateTime to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static OffsetTimeAssert assumeThat(OffsetTime actual)
```
    Creates a new instance of OffsetTimeAssert assumption.
    
    Parameters:
    
    actual - the LocalTime to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static LocalTimeAssert assumeThat(LocalTime actual)
```
    Creates a new instance of LocalTimeAssert assumption.
    
    Parameters:
    
    actual - the LocalTime to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static LocalDateAssert assumeThat(LocalDate actual)
```
    Creates a new instance of LocalDateAssert assumption.
    
    Parameters:
    
    actual - the LocalDate to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static InstantAssert assumeThat(Instant actual)
```
    Creates a new instance of InstantAssert assumption.
    
    Parameters:
    
    actual - the Instant to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static DurationAssert assumeThat(Duration actual)
```
    Creates a new instance of DurationAssert assumption.
    
    Parameters:
    
    actual - the Duration to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.15.0
  - assumeThat
```
public static PeriodAssert assumeThat(Period actual)
```
    Creates a new instance of PeriodAssert assumption.
    
    Parameters:
    
    actual - the Period to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.17.0
  - assumeThat
```
public static <ELEMENT> ListAssert<ELEMENT> assumeThat(Stream<? extends ELEMENT> actual)
```
    Creates a new instance of ListAssert assumption from the given Stream.
    
    Type Parameters:
    
    ELEMENT - the type of elements.
    
    Parameters:
    
    actual - the Stream to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static ListAssert<Double> assumeThat(DoubleStream actual)
```
    Creates a new instance of ListAssert assumption from the given DoubleStream.
    
    Parameters:
    
    actual - the DoubleStream to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static ListAssert<Long> assumeThat(LongStream actual)
```
    Creates a new instance of ListAssert assumption from the given LongStream.
    
    Parameters:
    
    actual - the LongStream to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static ListAssert<Integer> assumeThat(IntStream actual)
```
    Creates a new instance of ListAssert assumption from the given IntStream.
    
    Parameters:
    
    actual - the LongStream to test
    
    Returns:
    
    the created assumption for assertion object.
    
    Since:
    
    3.9.0
  - assumeThat
```
public static <ELEMENT> SpliteratorAssert<ELEMENT> assumeThat(Spliterator<ELEMENT> actual)
```
    Creates a new instance of SpliteratorAssert assumption from the given Spliterator.
    
    Type Parameters:
    
    ELEMENT - the type of the elements
    
    Parameters:
    
    actual - the Spliterator to test
    
    Returns:
    
    the created assumption for assertion object.
  - asAssumption
```
private static <ASSERTION,ACTUAL> ASSERTION asAssumption(Class<ASSERTION> assertionType,
                                                               Class<ACTUAL> actualType,
                                                               Object actual)
```
  - asAssumption
```
private static <ASSERTION> ASSERTION asAssumption(Class<ASSERTION> assertionType,
                                                  Class<?>[] constructorTypes,
                                                  Object... constructorParams)
```
  - createAssumptionClass
```
private static <ASSERTION> Class<? extends ASSERTION> createAssumptionClass(Class<ASSERTION> assertClass)
```
  - generateAssumptionClass
```
protected static <ASSERTION> Class<? extends ASSERTION> generateAssumptionClass(Class<ASSERTION> assertionType)
```
  - assumptionNotMet
```
private static RuntimeException assumptionNotMet(AssertionError assertionError)
                                          throws ReflectiveOperationException
```
    Throws:
    
    ReflectiveOperationException
  - getAssumptionClass
```
private static Class<?> getAssumptionClass(String className)
```
  - assumptionNotMet
```
private static RuntimeException assumptionNotMet(Class<?> exceptionClass,
                                                 AssertionError e)
                                          throws ReflectiveOperationException
```
    Throws:
    
    ReflectiveOperationException
  - asAssumption
```
private static AbstractAssert<?,?> asAssumption(AbstractAssert<?,?> assertion)
```
  - asRecursiveComparisonAssumption
```
private static AbstractAssert<?,?> asRecursiveComparisonAssumption(AbstractAssert<?,?> assertion)
```
  - asMapSizeAssumption
```
private static AbstractAssert<?,?> asMapSizeAssumption(AbstractAssert<?,?> assertion)
```
  - asIterableSizeAssumption
```
private static AbstractAssert<?,?> asIterableSizeAssumption(AbstractAssert<?,?> assertion)
```

Class Assumptions

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

BYTE_BUDDY

ASSUMPTION

CACHE

Constructor Detail

Assumptions

Method Detail

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat

assumeThat