Package eu.lunisolar.magma.func.asserts.std

Interface Summary

Interface	Description
BiConsumerAssert<S extends BiConsumerAssert<S,A,T1,T2>,A extends java.util.function.BiConsumer<T1,T2>,T1,T2>	Assert for java.util.function.BiConsumer.
BiFunctionAssert<S extends BiFunctionAssert<S,A,RS,T1,T2,R>,A extends java.util.function.BiFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Assert for java.util.function.BiFunction.
BinaryOperatorAssert<S extends BinaryOperatorAssert<S,A,RS,T>,A extends java.util.function.BinaryOperator<T>,RS extends org.assertj.core.api.Assert<RS,T>,T>	Assert for java.util.function.BinaryOperator.
BiPredicateAssert<S extends BiPredicateAssert<S,A,RS,T1,T2>,A extends java.util.function.BiPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2>	Assert for java.util.function.BiPredicate.
BooleanSupplierAssert<S extends BooleanSupplierAssert<S,A,RS>,A extends java.util.function.BooleanSupplier,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Assert for java.util.function.BooleanSupplier.
ConsumerAssert<S extends ConsumerAssert<S,A,T>,A extends java.util.function.Consumer<T>,T>	Assert for java.util.function.Consumer.
DoubleBinaryOperatorAssert<S extends DoubleBinaryOperatorAssert<S,A,RS>,A extends java.util.function.DoubleBinaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Assert for java.util.function.DoubleBinaryOperator.
DoubleConsumerAssert<S extends DoubleConsumerAssert<S,A>,A extends java.util.function.DoubleConsumer>	Assert for java.util.function.DoubleConsumer.
DoubleFunctionAssert<S extends DoubleFunctionAssert<S,A,RS,R>,A extends java.util.function.DoubleFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for java.util.function.DoubleFunction.
DoublePredicateAssert<S extends DoublePredicateAssert<S,A,RS>,A extends java.util.function.DoublePredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Assert for java.util.function.DoublePredicate.
DoubleSupplierAssert<S extends DoubleSupplierAssert<S,A,RS>,A extends java.util.function.DoubleSupplier,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Assert for java.util.function.DoubleSupplier.
DoubleToIntFunctionAssert<S extends DoubleToIntFunctionAssert<S,A,RS>,A extends java.util.function.DoubleToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Assert for java.util.function.DoubleToIntFunction.
DoubleToLongFunctionAssert<S extends DoubleToLongFunctionAssert<S,A,RS>,A extends java.util.function.DoubleToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Assert for java.util.function.DoubleToLongFunction.
DoubleUnaryOperatorAssert<S extends DoubleUnaryOperatorAssert<S,A,RS>,A extends java.util.function.DoubleUnaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Assert for java.util.function.DoubleUnaryOperator.
FunctionAssert<S extends FunctionAssert<S,A,RS,T,R>,A extends java.util.function.Function<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Assert for java.util.function.Function.
IntBinaryOperatorAssert<S extends IntBinaryOperatorAssert<S,A,RS>,A extends java.util.function.IntBinaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Assert for java.util.function.IntBinaryOperator.
IntConsumerAssert<S extends IntConsumerAssert<S,A>,A extends java.util.function.IntConsumer>	Assert for java.util.function.IntConsumer.
IntFunctionAssert<S extends IntFunctionAssert<S,A,RS,R>,A extends java.util.function.IntFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for java.util.function.IntFunction.
IntPredicateAssert<S extends IntPredicateAssert<S,A,RS>,A extends java.util.function.IntPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Assert for java.util.function.IntPredicate.
IntSupplierAssert<S extends IntSupplierAssert<S,A,RS>,A extends java.util.function.IntSupplier,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Assert for java.util.function.IntSupplier.
IntToDoubleFunctionAssert<S extends IntToDoubleFunctionAssert<S,A,RS>,A extends java.util.function.IntToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Assert for java.util.function.IntToDoubleFunction.
IntToLongFunctionAssert<S extends IntToLongFunctionAssert<S,A,RS>,A extends java.util.function.IntToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Assert for java.util.function.IntToLongFunction.
IntUnaryOperatorAssert<S extends IntUnaryOperatorAssert<S,A,RS>,A extends java.util.function.IntUnaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Assert for java.util.function.IntUnaryOperator.
LongBinaryOperatorAssert<S extends LongBinaryOperatorAssert<S,A,RS>,A extends java.util.function.LongBinaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Assert for java.util.function.LongBinaryOperator.
LongConsumerAssert<S extends LongConsumerAssert<S,A>,A extends java.util.function.LongConsumer>	Assert for java.util.function.LongConsumer.
LongFunctionAssert<S extends LongFunctionAssert<S,A,RS,R>,A extends java.util.function.LongFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for java.util.function.LongFunction.
LongPredicateAssert<S extends LongPredicateAssert<S,A,RS>,A extends java.util.function.LongPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Assert for java.util.function.LongPredicate.
LongSupplierAssert<S extends LongSupplierAssert<S,A,RS>,A extends java.util.function.LongSupplier,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Assert for java.util.function.LongSupplier.
LongToDoubleFunctionAssert<S extends LongToDoubleFunctionAssert<S,A,RS>,A extends java.util.function.LongToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Assert for java.util.function.LongToDoubleFunction.
LongToIntFunctionAssert<S extends LongToIntFunctionAssert<S,A,RS>,A extends java.util.function.LongToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Assert for java.util.function.LongToIntFunction.
LongUnaryOperatorAssert<S extends LongUnaryOperatorAssert<S,A,RS>,A extends java.util.function.LongUnaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Assert for java.util.function.LongUnaryOperator.
ObjDoubleConsumerAssert<S extends ObjDoubleConsumerAssert<S,A,T>,A extends java.util.function.ObjDoubleConsumer<T>,T>	Assert for java.util.function.ObjDoubleConsumer.
ObjIntConsumerAssert<S extends ObjIntConsumerAssert<S,A,T>,A extends java.util.function.ObjIntConsumer<T>,T>	Assert for java.util.function.ObjIntConsumer.
ObjLongConsumerAssert<S extends ObjLongConsumerAssert<S,A,T>,A extends java.util.function.ObjLongConsumer<T>,T>	Assert for java.util.function.ObjLongConsumer.
PredicateAssert<S extends PredicateAssert<S,A,RS,T>,A extends java.util.function.Predicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T>	Assert for java.util.function.Predicate.
SupplierAssert<S extends SupplierAssert<S,A,RS,R>,A extends java.util.function.Supplier<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for java.util.function.Supplier.
ToDoubleBiFunctionAssert<S extends ToDoubleBiFunctionAssert<S,A,RS,T1,T2>,A extends java.util.function.ToDoubleBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T1,T2>	Assert for java.util.function.ToDoubleBiFunction.
ToDoubleFunctionAssert<S extends ToDoubleFunctionAssert<S,A,RS,T>,A extends java.util.function.ToDoubleFunction<T>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T>	Assert for java.util.function.ToDoubleFunction.
ToIntBiFunctionAssert<S extends ToIntBiFunctionAssert<S,A,RS,T1,T2>,A extends java.util.function.ToIntBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T1,T2>	Assert for java.util.function.ToIntBiFunction.
ToIntFunctionAssert<S extends ToIntFunctionAssert<S,A,RS,T>,A extends java.util.function.ToIntFunction<T>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T>	Assert for java.util.function.ToIntFunction.
ToLongBiFunctionAssert<S extends ToLongBiFunctionAssert<S,A,RS,T1,T2>,A extends java.util.function.ToLongBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T1,T2>	Assert for java.util.function.ToLongBiFunction.
ToLongFunctionAssert<S extends ToLongFunctionAssert<S,A,RS,T>,A extends java.util.function.ToLongFunction<T>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T>	Assert for java.util.function.ToLongFunction.
UnaryOperatorAssert<S extends UnaryOperatorAssert<S,A,RS,T>,A extends java.util.function.UnaryOperator<T>,RS extends org.assertj.core.api.Assert<RS,T>,T>	Assert for java.util.function.UnaryOperator.

Class Summary

Class	Description
BiConsumerAssert.Base<S extends BiConsumerAssert.Base<S,A,T1,T2>,A extends java.util.function.BiConsumer<T1,T2>,T1,T2>	Base implementation.
BiConsumerAssert.The<A extends java.util.function.BiConsumer<T1,T2>,T1,T2>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
BiFunctionAssert.Base<S extends BiFunctionAssert.Base<S,A,RS,T1,T2,R>,A extends java.util.function.BiFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Base implementation.
BiFunctionAssert.The<A extends java.util.function.BiFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
BinaryOperatorAssert.Base<S extends BinaryOperatorAssert.Base<S,A,RS,T>,A extends java.util.function.BinaryOperator<T>,RS extends org.assertj.core.api.Assert<RS,T>,T>	Base implementation.
BinaryOperatorAssert.The<A extends java.util.function.BinaryOperator<T>,RS extends org.assertj.core.api.Assert<RS,T>,T>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
BiPredicateAssert.Base<S extends BiPredicateAssert.Base<S,A,RS,T1,T2>,A extends java.util.function.BiPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2>	Base implementation.
BiPredicateAssert.The<A extends java.util.function.BiPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
BooleanSupplierAssert.Base<S extends BooleanSupplierAssert.Base<S,A,RS>,A extends java.util.function.BooleanSupplier,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Base implementation.
BooleanSupplierAssert.The<A extends java.util.function.BooleanSupplier,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
ConsumerAssert.Base<S extends ConsumerAssert.Base<S,A,T>,A extends java.util.function.Consumer<T>,T>	Base implementation.
ConsumerAssert.The<A extends java.util.function.Consumer<T>,T>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
DoubleBinaryOperatorAssert.Base<S extends DoubleBinaryOperatorAssert.Base<S,A,RS>,A extends java.util.function.DoubleBinaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Base implementation.
DoubleBinaryOperatorAssert.The<A extends java.util.function.DoubleBinaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
DoubleConsumerAssert.Base<S extends DoubleConsumerAssert.Base<S,A>,A extends java.util.function.DoubleConsumer>	Base implementation.
DoubleConsumerAssert.The<A extends java.util.function.DoubleConsumer>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
DoubleFunctionAssert.Base<S extends DoubleFunctionAssert.Base<S,A,RS,R>,A extends java.util.function.DoubleFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
DoubleFunctionAssert.The<A extends java.util.function.DoubleFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
DoublePredicateAssert.Base<S extends DoublePredicateAssert.Base<S,A,RS>,A extends java.util.function.DoublePredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Base implementation.
DoublePredicateAssert.The<A extends java.util.function.DoublePredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
DoubleSupplierAssert.Base<S extends DoubleSupplierAssert.Base<S,A,RS>,A extends java.util.function.DoubleSupplier,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Base implementation.
DoubleSupplierAssert.The<A extends java.util.function.DoubleSupplier,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
DoubleToIntFunctionAssert.Base<S extends DoubleToIntFunctionAssert.Base<S,A,RS>,A extends java.util.function.DoubleToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Base implementation.
DoubleToIntFunctionAssert.The<A extends java.util.function.DoubleToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
DoubleToLongFunctionAssert.Base<S extends DoubleToLongFunctionAssert.Base<S,A,RS>,A extends java.util.function.DoubleToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Base implementation.
DoubleToLongFunctionAssert.The<A extends java.util.function.DoubleToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
DoubleUnaryOperatorAssert.Base<S extends DoubleUnaryOperatorAssert.Base<S,A,RS>,A extends java.util.function.DoubleUnaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Base implementation.
DoubleUnaryOperatorAssert.The<A extends java.util.function.DoubleUnaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
FunctionAssert.Base<S extends FunctionAssert.Base<S,A,RS,T,R>,A extends java.util.function.Function<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Base implementation.
FunctionAssert.The<A extends java.util.function.Function<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
IntBinaryOperatorAssert.Base<S extends IntBinaryOperatorAssert.Base<S,A,RS>,A extends java.util.function.IntBinaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Base implementation.
IntBinaryOperatorAssert.The<A extends java.util.function.IntBinaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
IntConsumerAssert.Base<S extends IntConsumerAssert.Base<S,A>,A extends java.util.function.IntConsumer>	Base implementation.
IntConsumerAssert.The<A extends java.util.function.IntConsumer>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
IntFunctionAssert.Base<S extends IntFunctionAssert.Base<S,A,RS,R>,A extends java.util.function.IntFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
IntFunctionAssert.The<A extends java.util.function.IntFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
IntPredicateAssert.Base<S extends IntPredicateAssert.Base<S,A,RS>,A extends java.util.function.IntPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Base implementation.
IntPredicateAssert.The<A extends java.util.function.IntPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
IntSupplierAssert.Base<S extends IntSupplierAssert.Base<S,A,RS>,A extends java.util.function.IntSupplier,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Base implementation.
IntSupplierAssert.The<A extends java.util.function.IntSupplier,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
IntToDoubleFunctionAssert.Base<S extends IntToDoubleFunctionAssert.Base<S,A,RS>,A extends java.util.function.IntToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Base implementation.
IntToDoubleFunctionAssert.The<A extends java.util.function.IntToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
IntToLongFunctionAssert.Base<S extends IntToLongFunctionAssert.Base<S,A,RS>,A extends java.util.function.IntToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Base implementation.
IntToLongFunctionAssert.The<A extends java.util.function.IntToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
IntUnaryOperatorAssert.Base<S extends IntUnaryOperatorAssert.Base<S,A,RS>,A extends java.util.function.IntUnaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Base implementation.
IntUnaryOperatorAssert.The<A extends java.util.function.IntUnaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LongBinaryOperatorAssert.Base<S extends LongBinaryOperatorAssert.Base<S,A,RS>,A extends java.util.function.LongBinaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Base implementation.
LongBinaryOperatorAssert.The<A extends java.util.function.LongBinaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LongConsumerAssert.Base<S extends LongConsumerAssert.Base<S,A>,A extends java.util.function.LongConsumer>	Base implementation.
LongConsumerAssert.The<A extends java.util.function.LongConsumer>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LongFunctionAssert.Base<S extends LongFunctionAssert.Base<S,A,RS,R>,A extends java.util.function.LongFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LongFunctionAssert.The<A extends java.util.function.LongFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LongPredicateAssert.Base<S extends LongPredicateAssert.Base<S,A,RS>,A extends java.util.function.LongPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Base implementation.
LongPredicateAssert.The<A extends java.util.function.LongPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LongSupplierAssert.Base<S extends LongSupplierAssert.Base<S,A,RS>,A extends java.util.function.LongSupplier,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Base implementation.
LongSupplierAssert.The<A extends java.util.function.LongSupplier,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LongToDoubleFunctionAssert.Base<S extends LongToDoubleFunctionAssert.Base<S,A,RS>,A extends java.util.function.LongToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Base implementation.
LongToDoubleFunctionAssert.The<A extends java.util.function.LongToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LongToIntFunctionAssert.Base<S extends LongToIntFunctionAssert.Base<S,A,RS>,A extends java.util.function.LongToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Base implementation.
LongToIntFunctionAssert.The<A extends java.util.function.LongToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LongUnaryOperatorAssert.Base<S extends LongUnaryOperatorAssert.Base<S,A,RS>,A extends java.util.function.LongUnaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Base implementation.
LongUnaryOperatorAssert.The<A extends java.util.function.LongUnaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
ObjDoubleConsumerAssert.Base<S extends ObjDoubleConsumerAssert.Base<S,A,T>,A extends java.util.function.ObjDoubleConsumer<T>,T>	Base implementation.
ObjDoubleConsumerAssert.The<A extends java.util.function.ObjDoubleConsumer<T>,T>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
ObjIntConsumerAssert.Base<S extends ObjIntConsumerAssert.Base<S,A,T>,A extends java.util.function.ObjIntConsumer<T>,T>	Base implementation.
ObjIntConsumerAssert.The<A extends java.util.function.ObjIntConsumer<T>,T>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
ObjLongConsumerAssert.Base<S extends ObjLongConsumerAssert.Base<S,A,T>,A extends java.util.function.ObjLongConsumer<T>,T>	Base implementation.
ObjLongConsumerAssert.The<A extends java.util.function.ObjLongConsumer<T>,T>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
PredicateAssert.Base<S extends PredicateAssert.Base<S,A,RS,T>,A extends java.util.function.Predicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T>	Base implementation.
PredicateAssert.The<A extends java.util.function.Predicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
SupplierAssert.Base<S extends SupplierAssert.Base<S,A,RS,R>,A extends java.util.function.Supplier<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
SupplierAssert.The<A extends java.util.function.Supplier<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
ToDoubleBiFunctionAssert.Base<S extends ToDoubleBiFunctionAssert.Base<S,A,RS,T1,T2>,A extends java.util.function.ToDoubleBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T1,T2>	Base implementation.
ToDoubleBiFunctionAssert.The<A extends java.util.function.ToDoubleBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T1,T2>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
ToDoubleFunctionAssert.Base<S extends ToDoubleFunctionAssert.Base<S,A,RS,T>,A extends java.util.function.ToDoubleFunction<T>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T>	Base implementation.
ToDoubleFunctionAssert.The<A extends java.util.function.ToDoubleFunction<T>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
ToIntBiFunctionAssert.Base<S extends ToIntBiFunctionAssert.Base<S,A,RS,T1,T2>,A extends java.util.function.ToIntBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T1,T2>	Base implementation.
ToIntBiFunctionAssert.The<A extends java.util.function.ToIntBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T1,T2>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
ToIntFunctionAssert.Base<S extends ToIntFunctionAssert.Base<S,A,RS,T>,A extends java.util.function.ToIntFunction<T>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T>	Base implementation.
ToIntFunctionAssert.The<A extends java.util.function.ToIntFunction<T>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
ToLongBiFunctionAssert.Base<S extends ToLongBiFunctionAssert.Base<S,A,RS,T1,T2>,A extends java.util.function.ToLongBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T1,T2>	Base implementation.
ToLongBiFunctionAssert.The<A extends java.util.function.ToLongBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T1,T2>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
ToLongFunctionAssert.Base<S extends ToLongFunctionAssert.Base<S,A,RS,T>,A extends java.util.function.ToLongFunction<T>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T>	Base implementation.
ToLongFunctionAssert.The<A extends java.util.function.ToLongFunction<T>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
UnaryOperatorAssert.Base<S extends UnaryOperatorAssert.Base<S,A,RS,T>,A extends java.util.function.UnaryOperator<T>,RS extends org.assertj.core.api.Assert<RS,T>,T>	Base implementation.
UnaryOperatorAssert.The<A extends java.util.function.UnaryOperator<T>,RS extends org.assertj.core.api.Assert<RS,T>,T>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).