Package eu.lunisolar.magma.func.asserts.function.from

Interface Summary

Interface	Description
LBiBoolFunctionAssert<S extends LBiBoolFunctionAssert<S,A,RS,R>,A extends LBiBoolFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for LBiBoolFunction.
LBiBoolFunctionXAssert<S extends LBiBoolFunctionXAssert<S,A,RS,R,X>,A extends LBiBoolFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Assert for LBiBoolFunctionX.
LBiByteFunctionAssert<S extends LBiByteFunctionAssert<S,A,RS,R>,A extends LBiByteFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for LBiByteFunction.
LBiByteFunctionXAssert<S extends LBiByteFunctionXAssert<S,A,RS,R,X>,A extends LBiByteFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Assert for LBiByteFunctionX.
LBiCharFunctionAssert<S extends LBiCharFunctionAssert<S,A,RS,R>,A extends LBiCharFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for LBiCharFunction.
LBiCharFunctionXAssert<S extends LBiCharFunctionXAssert<S,A,RS,R,X>,A extends LBiCharFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Assert for LBiCharFunctionX.
LBiDoubleFunctionAssert<S extends LBiDoubleFunctionAssert<S,A,RS,R>,A extends LBiDoubleFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for LBiDoubleFunction.
LBiDoubleFunctionXAssert<S extends LBiDoubleFunctionXAssert<S,A,RS,R,X>,A extends LBiDoubleFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Assert for LBiDoubleFunctionX.
LBiFloatFunctionAssert<S extends LBiFloatFunctionAssert<S,A,RS,R>,A extends LBiFloatFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for LBiFloatFunction.
LBiFloatFunctionXAssert<S extends LBiFloatFunctionXAssert<S,A,RS,R,X>,A extends LBiFloatFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Assert for LBiFloatFunctionX.
LBiIntFunctionAssert<S extends LBiIntFunctionAssert<S,A,RS,R>,A extends LBiIntFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for LBiIntFunction.
LBiIntFunctionXAssert<S extends LBiIntFunctionXAssert<S,A,RS,R,X>,A extends LBiIntFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Assert for LBiIntFunctionX.
LBiLongFunctionAssert<S extends LBiLongFunctionAssert<S,A,RS,R>,A extends LBiLongFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for LBiLongFunction.
LBiLongFunctionXAssert<S extends LBiLongFunctionXAssert<S,A,RS,R,X>,A extends LBiLongFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Assert for LBiLongFunctionX.
LBiObjBoolFunctionAssert<S extends LBiObjBoolFunctionAssert<S,A,RS,T1,T2,R>,A extends LBiObjBoolFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Assert for LBiObjBoolFunction.
LBiObjBoolFunctionXAssert<S extends LBiObjBoolFunctionXAssert<S,A,RS,T1,T2,R,X>,A extends LBiObjBoolFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Assert for LBiObjBoolFunctionX.
LBiObjByteFunctionAssert<S extends LBiObjByteFunctionAssert<S,A,RS,T1,T2,R>,A extends LBiObjByteFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Assert for LBiObjByteFunction.
LBiObjByteFunctionXAssert<S extends LBiObjByteFunctionXAssert<S,A,RS,T1,T2,R,X>,A extends LBiObjByteFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Assert for LBiObjByteFunctionX.
LBiObjCharFunctionAssert<S extends LBiObjCharFunctionAssert<S,A,RS,T1,T2,R>,A extends LBiObjCharFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Assert for LBiObjCharFunction.
LBiObjCharFunctionXAssert<S extends LBiObjCharFunctionXAssert<S,A,RS,T1,T2,R,X>,A extends LBiObjCharFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Assert for LBiObjCharFunctionX.
LBiObjDoubleFunctionAssert<S extends LBiObjDoubleFunctionAssert<S,A,RS,T1,T2,R>,A extends LBiObjDoubleFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Assert for LBiObjDoubleFunction.
LBiObjDoubleFunctionXAssert<S extends LBiObjDoubleFunctionXAssert<S,A,RS,T1,T2,R,X>,A extends LBiObjDoubleFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Assert for LBiObjDoubleFunctionX.
LBiObjFloatFunctionAssert<S extends LBiObjFloatFunctionAssert<S,A,RS,T1,T2,R>,A extends LBiObjFloatFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Assert for LBiObjFloatFunction.
LBiObjFloatFunctionXAssert<S extends LBiObjFloatFunctionXAssert<S,A,RS,T1,T2,R,X>,A extends LBiObjFloatFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Assert for LBiObjFloatFunctionX.
LBiObjIntFunctionAssert<S extends LBiObjIntFunctionAssert<S,A,RS,T1,T2,R>,A extends LBiObjIntFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Assert for LBiObjIntFunction.
LBiObjIntFunctionXAssert<S extends LBiObjIntFunctionXAssert<S,A,RS,T1,T2,R,X>,A extends LBiObjIntFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Assert for LBiObjIntFunctionX.
LBiObjLongFunctionAssert<S extends LBiObjLongFunctionAssert<S,A,RS,T1,T2,R>,A extends LBiObjLongFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Assert for LBiObjLongFunction.
LBiObjLongFunctionXAssert<S extends LBiObjLongFunctionXAssert<S,A,RS,T1,T2,R,X>,A extends LBiObjLongFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Assert for LBiObjLongFunctionX.
LBiObjShortFunctionAssert<S extends LBiObjShortFunctionAssert<S,A,RS,T1,T2,R>,A extends LBiObjShortFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Assert for LBiObjShortFunction.
LBiObjShortFunctionXAssert<S extends LBiObjShortFunctionXAssert<S,A,RS,T1,T2,R,X>,A extends LBiObjShortFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Assert for LBiObjShortFunctionX.
LBiShortFunctionAssert<S extends LBiShortFunctionAssert<S,A,RS,R>,A extends LBiShortFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for LBiShortFunction.
LBiShortFunctionXAssert<S extends LBiShortFunctionXAssert<S,A,RS,R,X>,A extends LBiShortFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Assert for LBiShortFunctionX.
LBoolFunctionAssert<S extends LBoolFunctionAssert<S,A,RS,R>,A extends LBoolFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for LBoolFunction.
LBoolFunctionXAssert<S extends LBoolFunctionXAssert<S,A,RS,R,X>,A extends LBoolFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Assert for LBoolFunctionX.
LByteFunctionAssert<S extends LByteFunctionAssert<S,A,RS,R>,A extends LByteFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for LByteFunction.
LByteFunctionXAssert<S extends LByteFunctionXAssert<S,A,RS,R,X>,A extends LByteFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Assert for LByteFunctionX.
LCharFunctionAssert<S extends LCharFunctionAssert<S,A,RS,R>,A extends LCharFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for LCharFunction.
LCharFunctionXAssert<S extends LCharFunctionXAssert<S,A,RS,R,X>,A extends LCharFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Assert for LCharFunctionX.
LDoubleFunctionAssert<S extends LDoubleFunctionAssert<S,A,RS,R>,A extends LDoubleFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for LDoubleFunction.
LDoubleFunctionXAssert<S extends LDoubleFunctionXAssert<S,A,RS,R,X>,A extends LDoubleFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Assert for LDoubleFunctionX.
LFloatFunctionAssert<S extends LFloatFunctionAssert<S,A,RS,R>,A extends LFloatFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for LFloatFunction.
LFloatFunctionXAssert<S extends LFloatFunctionXAssert<S,A,RS,R,X>,A extends LFloatFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Assert for LFloatFunctionX.
LIntFunctionAssert<S extends LIntFunctionAssert<S,A,RS,R>,A extends LIntFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for LIntFunction.
LIntFunctionXAssert<S extends LIntFunctionXAssert<S,A,RS,R,X>,A extends LIntFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Assert for LIntFunctionX.
LLongFunctionAssert<S extends LLongFunctionAssert<S,A,RS,R>,A extends LLongFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for LLongFunction.
LLongFunctionXAssert<S extends LLongFunctionXAssert<S,A,RS,R,X>,A extends LLongFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Assert for LLongFunctionX.
LObjBoolFunctionAssert<S extends LObjBoolFunctionAssert<S,A,RS,T,R>,A extends LObjBoolFunction<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Assert for LObjBoolFunction.
LObjBoolFunctionXAssert<S extends LObjBoolFunctionXAssert<S,A,RS,T,R,X>,A extends LObjBoolFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Assert for LObjBoolFunctionX.
LObjByteFunctionAssert<S extends LObjByteFunctionAssert<S,A,RS,T,R>,A extends LObjByteFunction<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Assert for LObjByteFunction.
LObjByteFunctionXAssert<S extends LObjByteFunctionXAssert<S,A,RS,T,R,X>,A extends LObjByteFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Assert for LObjByteFunctionX.
LObjCharFunctionAssert<S extends LObjCharFunctionAssert<S,A,RS,T,R>,A extends LObjCharFunction<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Assert for LObjCharFunction.
LObjCharFunctionXAssert<S extends LObjCharFunctionXAssert<S,A,RS,T,R,X>,A extends LObjCharFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Assert for LObjCharFunctionX.
LObjDoubleFunctionAssert<S extends LObjDoubleFunctionAssert<S,A,RS,T,R>,A extends LObjDoubleFunction<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Assert for LObjDoubleFunction.
LObjDoubleFunctionXAssert<S extends LObjDoubleFunctionXAssert<S,A,RS,T,R,X>,A extends LObjDoubleFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Assert for LObjDoubleFunctionX.
LObjFloatFunctionAssert<S extends LObjFloatFunctionAssert<S,A,RS,T,R>,A extends LObjFloatFunction<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Assert for LObjFloatFunction.
LObjFloatFunctionXAssert<S extends LObjFloatFunctionXAssert<S,A,RS,T,R,X>,A extends LObjFloatFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Assert for LObjFloatFunctionX.
LObjIntFunctionAssert<S extends LObjIntFunctionAssert<S,A,RS,T,R>,A extends LObjIntFunction<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Assert for LObjIntFunction.
LObjIntFunctionXAssert<S extends LObjIntFunctionXAssert<S,A,RS,T,R,X>,A extends LObjIntFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Assert for LObjIntFunctionX.
LObjLongFunctionAssert<S extends LObjLongFunctionAssert<S,A,RS,T,R>,A extends LObjLongFunction<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Assert for LObjLongFunction.
LObjLongFunctionXAssert<S extends LObjLongFunctionXAssert<S,A,RS,T,R,X>,A extends LObjLongFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Assert for LObjLongFunctionX.
LObjShortFunctionAssert<S extends LObjShortFunctionAssert<S,A,RS,T,R>,A extends LObjShortFunction<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Assert for LObjShortFunction.
LObjShortFunctionXAssert<S extends LObjShortFunctionXAssert<S,A,RS,T,R,X>,A extends LObjShortFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Assert for LObjShortFunctionX.
LShortFunctionAssert<S extends LShortFunctionAssert<S,A,RS,R>,A extends LShortFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for LShortFunction.
LShortFunctionXAssert<S extends LShortFunctionXAssert<S,A,RS,R,X>,A extends LShortFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Assert for LShortFunctionX.
LTriBoolFunctionAssert<S extends LTriBoolFunctionAssert<S,A,RS,R>,A extends LTriBoolFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Assert for LTriBoolFunction.
LTriBoolFunctionXAssert<S extends LTriBoolFunctionXAssert<S,A,RS,R,X>,A extends LTriBoolFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Assert for LTriBoolFunctionX.

Class Summary

Class	Description
LBiBoolFunctionAssert.Base<S extends LBiBoolFunctionAssert.Base<S,A,RS,R>,A extends LBiBoolFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LBiBoolFunctionAssert.The<A extends LBiBoolFunction<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).
LBiBoolFunctionXAssert.Base<S extends LBiBoolFunctionXAssert.Base<S,A,RS,R,X>,A extends LBiBoolFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Base implementation.
LBiBoolFunctionXAssert.The<A extends LBiBoolFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBiByteFunctionAssert.Base<S extends LBiByteFunctionAssert.Base<S,A,RS,R>,A extends LBiByteFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LBiByteFunctionAssert.The<A extends LBiByteFunction<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).
LBiByteFunctionXAssert.Base<S extends LBiByteFunctionXAssert.Base<S,A,RS,R,X>,A extends LBiByteFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Base implementation.
LBiByteFunctionXAssert.The<A extends LBiByteFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBiCharFunctionAssert.Base<S extends LBiCharFunctionAssert.Base<S,A,RS,R>,A extends LBiCharFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LBiCharFunctionAssert.The<A extends LBiCharFunction<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).
LBiCharFunctionXAssert.Base<S extends LBiCharFunctionXAssert.Base<S,A,RS,R,X>,A extends LBiCharFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Base implementation.
LBiCharFunctionXAssert.The<A extends LBiCharFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBiDoubleFunctionAssert.Base<S extends LBiDoubleFunctionAssert.Base<S,A,RS,R>,A extends LBiDoubleFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LBiDoubleFunctionAssert.The<A extends LBiDoubleFunction<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).
LBiDoubleFunctionXAssert.Base<S extends LBiDoubleFunctionXAssert.Base<S,A,RS,R,X>,A extends LBiDoubleFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Base implementation.
LBiDoubleFunctionXAssert.The<A extends LBiDoubleFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBiFloatFunctionAssert.Base<S extends LBiFloatFunctionAssert.Base<S,A,RS,R>,A extends LBiFloatFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LBiFloatFunctionAssert.The<A extends LBiFloatFunction<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).
LBiFloatFunctionXAssert.Base<S extends LBiFloatFunctionXAssert.Base<S,A,RS,R,X>,A extends LBiFloatFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Base implementation.
LBiFloatFunctionXAssert.The<A extends LBiFloatFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBiIntFunctionAssert.Base<S extends LBiIntFunctionAssert.Base<S,A,RS,R>,A extends LBiIntFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LBiIntFunctionAssert.The<A extends LBiIntFunction<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).
LBiIntFunctionXAssert.Base<S extends LBiIntFunctionXAssert.Base<S,A,RS,R,X>,A extends LBiIntFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Base implementation.
LBiIntFunctionXAssert.The<A extends LBiIntFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBiLongFunctionAssert.Base<S extends LBiLongFunctionAssert.Base<S,A,RS,R>,A extends LBiLongFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LBiLongFunctionAssert.The<A extends LBiLongFunction<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).
LBiLongFunctionXAssert.Base<S extends LBiLongFunctionXAssert.Base<S,A,RS,R,X>,A extends LBiLongFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Base implementation.
LBiLongFunctionXAssert.The<A extends LBiLongFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBiObjBoolFunctionAssert.Base<S extends LBiObjBoolFunctionAssert.Base<S,A,RS,T1,T2,R>,A extends LBiObjBoolFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Base implementation.
LBiObjBoolFunctionAssert.The<A extends LBiObjBoolFunction<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).
LBiObjBoolFunctionXAssert.Base<S extends LBiObjBoolFunctionXAssert.Base<S,A,RS,T1,T2,R,X>,A extends LBiObjBoolFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Base implementation.
LBiObjBoolFunctionXAssert.The<A extends LBiObjBoolFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBiObjByteFunctionAssert.Base<S extends LBiObjByteFunctionAssert.Base<S,A,RS,T1,T2,R>,A extends LBiObjByteFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Base implementation.
LBiObjByteFunctionAssert.The<A extends LBiObjByteFunction<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).
LBiObjByteFunctionXAssert.Base<S extends LBiObjByteFunctionXAssert.Base<S,A,RS,T1,T2,R,X>,A extends LBiObjByteFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Base implementation.
LBiObjByteFunctionXAssert.The<A extends LBiObjByteFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBiObjCharFunctionAssert.Base<S extends LBiObjCharFunctionAssert.Base<S,A,RS,T1,T2,R>,A extends LBiObjCharFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Base implementation.
LBiObjCharFunctionAssert.The<A extends LBiObjCharFunction<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).
LBiObjCharFunctionXAssert.Base<S extends LBiObjCharFunctionXAssert.Base<S,A,RS,T1,T2,R,X>,A extends LBiObjCharFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Base implementation.
LBiObjCharFunctionXAssert.The<A extends LBiObjCharFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBiObjDoubleFunctionAssert.Base<S extends LBiObjDoubleFunctionAssert.Base<S,A,RS,T1,T2,R>,A extends LBiObjDoubleFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Base implementation.
LBiObjDoubleFunctionAssert.The<A extends LBiObjDoubleFunction<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).
LBiObjDoubleFunctionXAssert.Base<S extends LBiObjDoubleFunctionXAssert.Base<S,A,RS,T1,T2,R,X>,A extends LBiObjDoubleFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Base implementation.
LBiObjDoubleFunctionXAssert.The<A extends LBiObjDoubleFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBiObjFloatFunctionAssert.Base<S extends LBiObjFloatFunctionAssert.Base<S,A,RS,T1,T2,R>,A extends LBiObjFloatFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Base implementation.
LBiObjFloatFunctionAssert.The<A extends LBiObjFloatFunction<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).
LBiObjFloatFunctionXAssert.Base<S extends LBiObjFloatFunctionXAssert.Base<S,A,RS,T1,T2,R,X>,A extends LBiObjFloatFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Base implementation.
LBiObjFloatFunctionXAssert.The<A extends LBiObjFloatFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBiObjIntFunctionAssert.Base<S extends LBiObjIntFunctionAssert.Base<S,A,RS,T1,T2,R>,A extends LBiObjIntFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Base implementation.
LBiObjIntFunctionAssert.The<A extends LBiObjIntFunction<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).
LBiObjIntFunctionXAssert.Base<S extends LBiObjIntFunctionXAssert.Base<S,A,RS,T1,T2,R,X>,A extends LBiObjIntFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Base implementation.
LBiObjIntFunctionXAssert.The<A extends LBiObjIntFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBiObjLongFunctionAssert.Base<S extends LBiObjLongFunctionAssert.Base<S,A,RS,T1,T2,R>,A extends LBiObjLongFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Base implementation.
LBiObjLongFunctionAssert.The<A extends LBiObjLongFunction<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).
LBiObjLongFunctionXAssert.Base<S extends LBiObjLongFunctionXAssert.Base<S,A,RS,T1,T2,R,X>,A extends LBiObjLongFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Base implementation.
LBiObjLongFunctionXAssert.The<A extends LBiObjLongFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBiObjShortFunctionAssert.Base<S extends LBiObjShortFunctionAssert.Base<S,A,RS,T1,T2,R>,A extends LBiObjShortFunction<T1,T2,R>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R>	Base implementation.
LBiObjShortFunctionAssert.The<A extends LBiObjShortFunction<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).
LBiObjShortFunctionXAssert.Base<S extends LBiObjShortFunctionXAssert.Base<S,A,RS,T1,T2,R,X>,A extends LBiObjShortFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Base implementation.
LBiObjShortFunctionXAssert.The<A extends LBiObjShortFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T1,T2,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBiShortFunctionAssert.Base<S extends LBiShortFunctionAssert.Base<S,A,RS,R>,A extends LBiShortFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LBiShortFunctionAssert.The<A extends LBiShortFunction<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).
LBiShortFunctionXAssert.Base<S extends LBiShortFunctionXAssert.Base<S,A,RS,R,X>,A extends LBiShortFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Base implementation.
LBiShortFunctionXAssert.The<A extends LBiShortFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBoolFunctionAssert.Base<S extends LBoolFunctionAssert.Base<S,A,RS,R>,A extends LBoolFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LBoolFunctionAssert.The<A extends LBoolFunction<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).
LBoolFunctionXAssert.Base<S extends LBoolFunctionXAssert.Base<S,A,RS,R,X>,A extends LBoolFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Base implementation.
LBoolFunctionXAssert.The<A extends LBoolFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LByteFunctionAssert.Base<S extends LByteFunctionAssert.Base<S,A,RS,R>,A extends LByteFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LByteFunctionAssert.The<A extends LByteFunction<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).
LByteFunctionXAssert.Base<S extends LByteFunctionXAssert.Base<S,A,RS,R,X>,A extends LByteFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Base implementation.
LByteFunctionXAssert.The<A extends LByteFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LCharFunctionAssert.Base<S extends LCharFunctionAssert.Base<S,A,RS,R>,A extends LCharFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LCharFunctionAssert.The<A extends LCharFunction<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).
LCharFunctionXAssert.Base<S extends LCharFunctionXAssert.Base<S,A,RS,R,X>,A extends LCharFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Base implementation.
LCharFunctionXAssert.The<A extends LCharFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LDoubleFunctionAssert.Base<S extends LDoubleFunctionAssert.Base<S,A,RS,R>,A extends LDoubleFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LDoubleFunctionAssert.The<A extends LDoubleFunction<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).
LDoubleFunctionXAssert.Base<S extends LDoubleFunctionXAssert.Base<S,A,RS,R,X>,A extends LDoubleFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Base implementation.
LDoubleFunctionXAssert.The<A extends LDoubleFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LFloatFunctionAssert.Base<S extends LFloatFunctionAssert.Base<S,A,RS,R>,A extends LFloatFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LFloatFunctionAssert.The<A extends LFloatFunction<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).
LFloatFunctionXAssert.Base<S extends LFloatFunctionXAssert.Base<S,A,RS,R,X>,A extends LFloatFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Base implementation.
LFloatFunctionXAssert.The<A extends LFloatFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LIntFunctionAssert.Base<S extends LIntFunctionAssert.Base<S,A,RS,R>,A extends LIntFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LIntFunctionAssert.The<A extends LIntFunction<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).
LIntFunctionXAssert.Base<S extends LIntFunctionXAssert.Base<S,A,RS,R,X>,A extends LIntFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Base implementation.
LIntFunctionXAssert.The<A extends LIntFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LLongFunctionAssert.Base<S extends LLongFunctionAssert.Base<S,A,RS,R>,A extends LLongFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LLongFunctionAssert.The<A extends LLongFunction<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).
LLongFunctionXAssert.Base<S extends LLongFunctionXAssert.Base<S,A,RS,R,X>,A extends LLongFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Base implementation.
LLongFunctionXAssert.The<A extends LLongFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LObjBoolFunctionAssert.Base<S extends LObjBoolFunctionAssert.Base<S,A,RS,T,R>,A extends LObjBoolFunction<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Base implementation.
LObjBoolFunctionAssert.The<A extends LObjBoolFunction<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).
LObjBoolFunctionXAssert.Base<S extends LObjBoolFunctionXAssert.Base<S,A,RS,T,R,X>,A extends LObjBoolFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Base implementation.
LObjBoolFunctionXAssert.The<A extends LObjBoolFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LObjByteFunctionAssert.Base<S extends LObjByteFunctionAssert.Base<S,A,RS,T,R>,A extends LObjByteFunction<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Base implementation.
LObjByteFunctionAssert.The<A extends LObjByteFunction<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).
LObjByteFunctionXAssert.Base<S extends LObjByteFunctionXAssert.Base<S,A,RS,T,R,X>,A extends LObjByteFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Base implementation.
LObjByteFunctionXAssert.The<A extends LObjByteFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LObjCharFunctionAssert.Base<S extends LObjCharFunctionAssert.Base<S,A,RS,T,R>,A extends LObjCharFunction<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Base implementation.
LObjCharFunctionAssert.The<A extends LObjCharFunction<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).
LObjCharFunctionXAssert.Base<S extends LObjCharFunctionXAssert.Base<S,A,RS,T,R,X>,A extends LObjCharFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Base implementation.
LObjCharFunctionXAssert.The<A extends LObjCharFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LObjDoubleFunctionAssert.Base<S extends LObjDoubleFunctionAssert.Base<S,A,RS,T,R>,A extends LObjDoubleFunction<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Base implementation.
LObjDoubleFunctionAssert.The<A extends LObjDoubleFunction<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).
LObjDoubleFunctionXAssert.Base<S extends LObjDoubleFunctionXAssert.Base<S,A,RS,T,R,X>,A extends LObjDoubleFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Base implementation.
LObjDoubleFunctionXAssert.The<A extends LObjDoubleFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LObjFloatFunctionAssert.Base<S extends LObjFloatFunctionAssert.Base<S,A,RS,T,R>,A extends LObjFloatFunction<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Base implementation.
LObjFloatFunctionAssert.The<A extends LObjFloatFunction<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).
LObjFloatFunctionXAssert.Base<S extends LObjFloatFunctionXAssert.Base<S,A,RS,T,R,X>,A extends LObjFloatFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Base implementation.
LObjFloatFunctionXAssert.The<A extends LObjFloatFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LObjIntFunctionAssert.Base<S extends LObjIntFunctionAssert.Base<S,A,RS,T,R>,A extends LObjIntFunction<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Base implementation.
LObjIntFunctionAssert.The<A extends LObjIntFunction<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).
LObjIntFunctionXAssert.Base<S extends LObjIntFunctionXAssert.Base<S,A,RS,T,R,X>,A extends LObjIntFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Base implementation.
LObjIntFunctionXAssert.The<A extends LObjIntFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LObjLongFunctionAssert.Base<S extends LObjLongFunctionAssert.Base<S,A,RS,T,R>,A extends LObjLongFunction<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Base implementation.
LObjLongFunctionAssert.The<A extends LObjLongFunction<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).
LObjLongFunctionXAssert.Base<S extends LObjLongFunctionXAssert.Base<S,A,RS,T,R,X>,A extends LObjLongFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Base implementation.
LObjLongFunctionXAssert.The<A extends LObjLongFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LObjShortFunctionAssert.Base<S extends LObjShortFunctionAssert.Base<S,A,RS,T,R>,A extends LObjShortFunction<T,R>,RS extends org.assertj.core.api.Assert<RS,R>,T,R>	Base implementation.
LObjShortFunctionAssert.The<A extends LObjShortFunction<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).
LObjShortFunctionXAssert.Base<S extends LObjShortFunctionXAssert.Base<S,A,RS,T,R,X>,A extends LObjShortFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Base implementation.
LObjShortFunctionXAssert.The<A extends LObjShortFunctionX<T,R,X>,RS extends org.assertj.core.api.Assert<RS,R>,T,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LShortFunctionAssert.Base<S extends LShortFunctionAssert.Base<S,A,RS,R>,A extends LShortFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LShortFunctionAssert.The<A extends LShortFunction<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).
LShortFunctionXAssert.Base<S extends LShortFunctionXAssert.Base<S,A,RS,R,X>,A extends LShortFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Base implementation.
LShortFunctionXAssert.The<A extends LShortFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LTriBoolFunctionAssert.Base<S extends LTriBoolFunctionAssert.Base<S,A,RS,R>,A extends LTriBoolFunction<R>,RS extends org.assertj.core.api.Assert<RS,R>,R>	Base implementation.
LTriBoolFunctionAssert.The<A extends LTriBoolFunction<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).
LTriBoolFunctionXAssert.Base<S extends LTriBoolFunctionXAssert.Base<S,A,RS,R,X>,A extends LTriBoolFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Base implementation.
LTriBoolFunctionXAssert.The<A extends LTriBoolFunctionX<R,X>,RS extends org.assertj.core.api.Assert<RS,R>,R,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).