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

Interface Summary

Interface	Description
JreBiConsumerAssert<S extends JreBiConsumerAssert<S,A,T1,T2>,A extends java.util.function.BiConsumer<T1,T2>,T1,T2>	Assert class for BiConsumer.
JreBiFunctionAssert<S extends JreBiFunctionAssert<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 class for BiFunction.
JreBinaryOperatorAssert<S extends JreBinaryOperatorAssert<S,A,RS,T>,A extends java.util.function.BinaryOperator<T>,RS extends org.assertj.core.api.Assert<RS,T>,T>	Assert class for BinaryOperator.
JreBiPredicateAssert<S extends JreBiPredicateAssert<S,A,RS,T1,T2>,A extends java.util.function.BiPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2>	Assert class for BiPredicate.
JreBooleanSupplierAssert<S extends JreBooleanSupplierAssert<S,A,RS>,A extends java.util.function.BooleanSupplier,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Assert class for BooleanSupplier.
JreConsumerAssert<S extends JreConsumerAssert<S,A,T>,A extends java.util.function.Consumer<T>,T>	Assert class for Consumer.
JreDoubleBinaryOperatorAssert<S extends JreDoubleBinaryOperatorAssert<S,A,RS>,A extends java.util.function.DoubleBinaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Assert class for DoubleBinaryOperator.
JreDoubleConsumerAssert<S extends JreDoubleConsumerAssert<S,A>,A extends java.util.function.DoubleConsumer>	Assert class for DoubleConsumer.
JreDoubleFunctionAssert<S extends JreDoubleFunctionAssert<S,A,RS,R>,A extends java.util.function.DoubleFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert class for DoubleFunction.
JreDoublePredicateAssert<S extends JreDoublePredicateAssert<S,A,RS>,A extends java.util.function.DoublePredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Assert class for DoublePredicate.
JreDoubleSupplierAssert<S extends JreDoubleSupplierAssert<S,A,RS>,A extends java.util.function.DoubleSupplier,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Assert class for DoubleSupplier.
JreDoubleToIntFunctionAssert<S extends JreDoubleToIntFunctionAssert<S,A,RS>,A extends java.util.function.DoubleToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Assert class for DoubleToIntFunction.
JreDoubleToLongFunctionAssert<S extends JreDoubleToLongFunctionAssert<S,A,RS>,A extends java.util.function.DoubleToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Assert class for DoubleToLongFunction.
JreDoubleUnaryOperatorAssert<S extends JreDoubleUnaryOperatorAssert<S,A,RS>,A extends java.util.function.DoubleUnaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Assert class for DoubleUnaryOperator.
JreFunctionAssert<S extends JreFunctionAssert<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 class for Function.
JreIntBinaryOperatorAssert<S extends JreIntBinaryOperatorAssert<S,A,RS>,A extends java.util.function.IntBinaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Assert class for IntBinaryOperator.
JreIntConsumerAssert<S extends JreIntConsumerAssert<S,A>,A extends java.util.function.IntConsumer>	Assert class for IntConsumer.
JreIntFunctionAssert<S extends JreIntFunctionAssert<S,A,RS,R>,A extends java.util.function.IntFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert class for IntFunction.
JreIntPredicateAssert<S extends JreIntPredicateAssert<S,A,RS>,A extends java.util.function.IntPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Assert class for IntPredicate.
JreIntSupplierAssert<S extends JreIntSupplierAssert<S,A,RS>,A extends java.util.function.IntSupplier,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Assert class for IntSupplier.
JreIntToDoubleFunctionAssert<S extends JreIntToDoubleFunctionAssert<S,A,RS>,A extends java.util.function.IntToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Assert class for IntToDoubleFunction.
JreIntToLongFunctionAssert<S extends JreIntToLongFunctionAssert<S,A,RS>,A extends java.util.function.IntToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Assert class for IntToLongFunction.
JreIntUnaryOperatorAssert<S extends JreIntUnaryOperatorAssert<S,A,RS>,A extends java.util.function.IntUnaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Assert class for IntUnaryOperator.
JreLongBinaryOperatorAssert<S extends JreLongBinaryOperatorAssert<S,A,RS>,A extends java.util.function.LongBinaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Assert class for LongBinaryOperator.
JreLongConsumerAssert<S extends JreLongConsumerAssert<S,A>,A extends java.util.function.LongConsumer>	Assert class for LongConsumer.
JreLongFunctionAssert<S extends JreLongFunctionAssert<S,A,RS,R>,A extends java.util.function.LongFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert class for LongFunction.
JreLongPredicateAssert<S extends JreLongPredicateAssert<S,A,RS>,A extends java.util.function.LongPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Assert class for LongPredicate.
JreLongSupplierAssert<S extends JreLongSupplierAssert<S,A,RS>,A extends java.util.function.LongSupplier,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Assert class for LongSupplier.
JreLongToDoubleFunctionAssert<S extends JreLongToDoubleFunctionAssert<S,A,RS>,A extends java.util.function.LongToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Assert class for LongToDoubleFunction.
JreLongToIntFunctionAssert<S extends JreLongToIntFunctionAssert<S,A,RS>,A extends java.util.function.LongToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Assert class for LongToIntFunction.
JreLongUnaryOperatorAssert<S extends JreLongUnaryOperatorAssert<S,A,RS>,A extends java.util.function.LongUnaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Assert class for LongUnaryOperator.
JreObjDoubleConsumerAssert<S extends JreObjDoubleConsumerAssert<S,A,T>,A extends java.util.function.ObjDoubleConsumer<T>,T>	Assert class for ObjDoubleConsumer.
JreObjIntConsumerAssert<S extends JreObjIntConsumerAssert<S,A,T>,A extends java.util.function.ObjIntConsumer<T>,T>	Assert class for ObjIntConsumer.
JreObjLongConsumerAssert<S extends JreObjLongConsumerAssert<S,A,T>,A extends java.util.function.ObjLongConsumer<T>,T>	Assert class for ObjLongConsumer.
JrePredicateAssert<S extends JrePredicateAssert<S,A,RS,T>,A extends java.util.function.Predicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T>	Assert class for Predicate.
JreRunnableAssert<S extends JreRunnableAssert<S,A>,A extends Runnable>	Assert class for Runnable.
JreSupplierAssert<S extends JreSupplierAssert<S,A,RS,T>,A extends java.util.function.Supplier<T>,RS extends org.assertj.core.api.Assert<RS,T>,T>	Assert class for Supplier.
JreToDoubleBiFunctionAssert<S extends JreToDoubleBiFunctionAssert<S,A,RS,T1,T2>,A extends java.util.function.ToDoubleBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T1,T2>	Assert class for ToDoubleBiFunction.
JreToDoubleFunctionAssert<S extends JreToDoubleFunctionAssert<S,A,RS,T>,A extends java.util.function.ToDoubleFunction<T>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T>	Assert class for ToDoubleFunction.
JreToIntBiFunctionAssert<S extends JreToIntBiFunctionAssert<S,A,RS,T1,T2>,A extends java.util.function.ToIntBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T1,T2>	Assert class for ToIntBiFunction.
JreToIntFunctionAssert<S extends JreToIntFunctionAssert<S,A,RS,T>,A extends java.util.function.ToIntFunction<T>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T>	Assert class for ToIntFunction.
JreToLongBiFunctionAssert<S extends JreToLongBiFunctionAssert<S,A,RS,T1,T2>,A extends java.util.function.ToLongBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T1,T2>	Assert class for ToLongBiFunction.
JreToLongFunctionAssert<S extends JreToLongFunctionAssert<S,A,RS,T>,A extends java.util.function.ToLongFunction<T>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T>	Assert class for ToLongFunction.
JreUnaryOperatorAssert<S extends JreUnaryOperatorAssert<S,A,RS,T>,A extends java.util.function.UnaryOperator<T>,RS extends org.assertj.core.api.Assert<RS,T>,T>	Assert class for UnaryOperator.

Class Summary

Class	Description
JreBiConsumerAssert.Base<S extends JreBiConsumerAssert.Base<S,A,T1,T2>,A extends java.util.function.BiConsumer<T1,T2>,T1,T2>	Base implementation.
JreBiConsumerAssert.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).
JreBiFunctionAssert.Base<S extends JreBiFunctionAssert.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.
JreBiFunctionAssert.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).
JreBinaryOperatorAssert.Base<S extends JreBinaryOperatorAssert.Base<S,A,RS,T>,A extends java.util.function.BinaryOperator<T>,RS extends org.assertj.core.api.Assert<RS,T>,T>	Base implementation.
JreBinaryOperatorAssert.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).
JreBiPredicateAssert.Base<S extends JreBiPredicateAssert.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.
JreBiPredicateAssert.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).
JreBooleanSupplierAssert.Base<S extends JreBooleanSupplierAssert.Base<S,A,RS>,A extends java.util.function.BooleanSupplier,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Base implementation.
JreBooleanSupplierAssert.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).
JreConsumerAssert.Base<S extends JreConsumerAssert.Base<S,A,T>,A extends java.util.function.Consumer<T>,T>	Base implementation.
JreConsumerAssert.The<A extends java.util.function.Consumer<T>,T>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
JreDoubleBinaryOperatorAssert.Base<S extends JreDoubleBinaryOperatorAssert.Base<S,A,RS>,A extends java.util.function.DoubleBinaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Base implementation.
JreDoubleBinaryOperatorAssert.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).
JreDoubleConsumerAssert.Base<S extends JreDoubleConsumerAssert.Base<S,A>,A extends java.util.function.DoubleConsumer>	Base implementation.
JreDoubleConsumerAssert.The<A extends java.util.function.DoubleConsumer>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
JreDoubleFunctionAssert.Base<S extends JreDoubleFunctionAssert.Base<S,A,RS,R>,A extends java.util.function.DoubleFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
JreDoubleFunctionAssert.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).
JreDoublePredicateAssert.Base<S extends JreDoublePredicateAssert.Base<S,A,RS>,A extends java.util.function.DoublePredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Base implementation.
JreDoublePredicateAssert.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).
JreDoubleSupplierAssert.Base<S extends JreDoubleSupplierAssert.Base<S,A,RS>,A extends java.util.function.DoubleSupplier,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Base implementation.
JreDoubleSupplierAssert.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).
JreDoubleToIntFunctionAssert.Base<S extends JreDoubleToIntFunctionAssert.Base<S,A,RS>,A extends java.util.function.DoubleToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Base implementation.
JreDoubleToIntFunctionAssert.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).
JreDoubleToLongFunctionAssert.Base<S extends JreDoubleToLongFunctionAssert.Base<S,A,RS>,A extends java.util.function.DoubleToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Base implementation.
JreDoubleToLongFunctionAssert.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).
JreDoubleUnaryOperatorAssert.Base<S extends JreDoubleUnaryOperatorAssert.Base<S,A,RS>,A extends java.util.function.DoubleUnaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Base implementation.
JreDoubleUnaryOperatorAssert.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).
JreFunctionAssert.Base<S extends JreFunctionAssert.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.
JreFunctionAssert.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).
JreIntBinaryOperatorAssert.Base<S extends JreIntBinaryOperatorAssert.Base<S,A,RS>,A extends java.util.function.IntBinaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Base implementation.
JreIntBinaryOperatorAssert.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).
JreIntConsumerAssert.Base<S extends JreIntConsumerAssert.Base<S,A>,A extends java.util.function.IntConsumer>	Base implementation.
JreIntConsumerAssert.The<A extends java.util.function.IntConsumer>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
JreIntFunctionAssert.Base<S extends JreIntFunctionAssert.Base<S,A,RS,R>,A extends java.util.function.IntFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
JreIntFunctionAssert.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).
JreIntPredicateAssert.Base<S extends JreIntPredicateAssert.Base<S,A,RS>,A extends java.util.function.IntPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Base implementation.
JreIntPredicateAssert.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).
JreIntSupplierAssert.Base<S extends JreIntSupplierAssert.Base<S,A,RS>,A extends java.util.function.IntSupplier,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Base implementation.
JreIntSupplierAssert.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).
JreIntToDoubleFunctionAssert.Base<S extends JreIntToDoubleFunctionAssert.Base<S,A,RS>,A extends java.util.function.IntToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Base implementation.
JreIntToDoubleFunctionAssert.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).
JreIntToLongFunctionAssert.Base<S extends JreIntToLongFunctionAssert.Base<S,A,RS>,A extends java.util.function.IntToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Base implementation.
JreIntToLongFunctionAssert.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).
JreIntUnaryOperatorAssert.Base<S extends JreIntUnaryOperatorAssert.Base<S,A,RS>,A extends java.util.function.IntUnaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Base implementation.
JreIntUnaryOperatorAssert.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).
JreLongBinaryOperatorAssert.Base<S extends JreLongBinaryOperatorAssert.Base<S,A,RS>,A extends java.util.function.LongBinaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Base implementation.
JreLongBinaryOperatorAssert.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).
JreLongConsumerAssert.Base<S extends JreLongConsumerAssert.Base<S,A>,A extends java.util.function.LongConsumer>	Base implementation.
JreLongConsumerAssert.The<A extends java.util.function.LongConsumer>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
JreLongFunctionAssert.Base<S extends JreLongFunctionAssert.Base<S,A,RS,R>,A extends java.util.function.LongFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
JreLongFunctionAssert.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).
JreLongPredicateAssert.Base<S extends JreLongPredicateAssert.Base<S,A,RS>,A extends java.util.function.LongPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>>	Base implementation.
JreLongPredicateAssert.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).
JreLongSupplierAssert.Base<S extends JreLongSupplierAssert.Base<S,A,RS>,A extends java.util.function.LongSupplier,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Base implementation.
JreLongSupplierAssert.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).
JreLongToDoubleFunctionAssert.Base<S extends JreLongToDoubleFunctionAssert.Base<S,A,RS>,A extends java.util.function.LongToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Base implementation.
JreLongToDoubleFunctionAssert.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).
JreLongToIntFunctionAssert.Base<S extends JreLongToIntFunctionAssert.Base<S,A,RS>,A extends java.util.function.LongToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Base implementation.
JreLongToIntFunctionAssert.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).
JreLongUnaryOperatorAssert.Base<S extends JreLongUnaryOperatorAssert.Base<S,A,RS>,A extends java.util.function.LongUnaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Base implementation.
JreLongUnaryOperatorAssert.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).
JreObjDoubleConsumerAssert.Base<S extends JreObjDoubleConsumerAssert.Base<S,A,T>,A extends java.util.function.ObjDoubleConsumer<T>,T>	Base implementation.
JreObjDoubleConsumerAssert.The<A extends java.util.function.ObjDoubleConsumer<T>,T>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
JreObjIntConsumerAssert.Base<S extends JreObjIntConsumerAssert.Base<S,A,T>,A extends java.util.function.ObjIntConsumer<T>,T>	Base implementation.
JreObjIntConsumerAssert.The<A extends java.util.function.ObjIntConsumer<T>,T>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
JreObjLongConsumerAssert.Base<S extends JreObjLongConsumerAssert.Base<S,A,T>,A extends java.util.function.ObjLongConsumer<T>,T>	Base implementation.
JreObjLongConsumerAssert.The<A extends java.util.function.ObjLongConsumer<T>,T>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
JrePredicateAssert.Base<S extends JrePredicateAssert.Base<S,A,RS,T>,A extends java.util.function.Predicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T>	Base implementation.
JrePredicateAssert.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).
JreRunnableAssert.Base<S extends JreRunnableAssert.Base<S,A>,A extends Runnable>	Base implementation.
JreRunnableAssert.The<A extends Runnable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
JreSupplierAssert.Base<S extends JreSupplierAssert.Base<S,A,RS,T>,A extends java.util.function.Supplier<T>,RS extends org.assertj.core.api.Assert<RS,T>,T>	Base implementation.
JreSupplierAssert.The<A extends java.util.function.Supplier<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).
JreToDoubleBiFunctionAssert.Base<S extends JreToDoubleBiFunctionAssert.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.
JreToDoubleBiFunctionAssert.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).
JreToDoubleFunctionAssert.Base<S extends JreToDoubleFunctionAssert.Base<S,A,RS,T>,A extends java.util.function.ToDoubleFunction<T>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T>	Base implementation.
JreToDoubleFunctionAssert.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).
JreToIntBiFunctionAssert.Base<S extends JreToIntBiFunctionAssert.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.
JreToIntBiFunctionAssert.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).
JreToIntFunctionAssert.Base<S extends JreToIntFunctionAssert.Base<S,A,RS,T>,A extends java.util.function.ToIntFunction<T>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T>	Base implementation.
JreToIntFunctionAssert.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).
JreToLongBiFunctionAssert.Base<S extends JreToLongBiFunctionAssert.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.
JreToLongBiFunctionAssert.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).
JreToLongFunctionAssert.Base<S extends JreToLongFunctionAssert.Base<S,A,RS,T>,A extends java.util.function.ToLongFunction<T>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T>	Base implementation.
JreToLongFunctionAssert.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).
JreUnaryOperatorAssert.Base<S extends JreUnaryOperatorAssert.Base<S,A,RS,T>,A extends java.util.function.UnaryOperator<T>,RS extends org.assertj.core.api.Assert<RS,T>,T>	Base implementation.
JreUnaryOperatorAssert.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).