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

Interface Summary

Interface	Description
LBoolToByteFunctionAssert<S extends LBoolToByteFunctionAssert<S,A,RS>,A extends LBoolToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Assert for LBoolToByteFunction.
LBoolToByteFunctionXAssert<S extends LBoolToByteFunctionXAssert<S,A,RS,X>,A extends LBoolToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Assert for LBoolToByteFunctionX.
LBoolToCharFunctionAssert<S extends LBoolToCharFunctionAssert<S,A,RS>,A extends LBoolToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Assert for LBoolToCharFunction.
LBoolToCharFunctionXAssert<S extends LBoolToCharFunctionXAssert<S,A,RS,X>,A extends LBoolToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Assert for LBoolToCharFunctionX.
LBoolToDoubleFunctionAssert<S extends LBoolToDoubleFunctionAssert<S,A,RS>,A extends LBoolToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Assert for LBoolToDoubleFunction.
LBoolToDoubleFunctionXAssert<S extends LBoolToDoubleFunctionXAssert<S,A,RS,X>,A extends LBoolToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Assert for LBoolToDoubleFunctionX.
LBoolToFloatFunctionAssert<S extends LBoolToFloatFunctionAssert<S,A,RS>,A extends LBoolToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Assert for LBoolToFloatFunction.
LBoolToFloatFunctionXAssert<S extends LBoolToFloatFunctionXAssert<S,A,RS,X>,A extends LBoolToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Assert for LBoolToFloatFunctionX.
LBoolToIntFunctionAssert<S extends LBoolToIntFunctionAssert<S,A,RS>,A extends LBoolToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Assert for LBoolToIntFunction.
LBoolToIntFunctionXAssert<S extends LBoolToIntFunctionXAssert<S,A,RS,X>,A extends LBoolToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Assert for LBoolToIntFunctionX.
LBoolToLongFunctionAssert<S extends LBoolToLongFunctionAssert<S,A,RS>,A extends LBoolToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Assert for LBoolToLongFunction.
LBoolToLongFunctionXAssert<S extends LBoolToLongFunctionXAssert<S,A,RS,X>,A extends LBoolToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Assert for LBoolToLongFunctionX.
LBoolToShortFunctionAssert<S extends LBoolToShortFunctionAssert<S,A,RS>,A extends LBoolToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Assert for LBoolToShortFunction.
LBoolToShortFunctionXAssert<S extends LBoolToShortFunctionXAssert<S,A,RS,X>,A extends LBoolToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Assert for LBoolToShortFunctionX.
LByteToCharFunctionAssert<S extends LByteToCharFunctionAssert<S,A,RS>,A extends LByteToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Assert for LByteToCharFunction.
LByteToCharFunctionXAssert<S extends LByteToCharFunctionXAssert<S,A,RS,X>,A extends LByteToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Assert for LByteToCharFunctionX.
LByteToDoubleFunctionAssert<S extends LByteToDoubleFunctionAssert<S,A,RS>,A extends LByteToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Assert for LByteToDoubleFunction.
LByteToDoubleFunctionXAssert<S extends LByteToDoubleFunctionXAssert<S,A,RS,X>,A extends LByteToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Assert for LByteToDoubleFunctionX.
LByteToFloatFunctionAssert<S extends LByteToFloatFunctionAssert<S,A,RS>,A extends LByteToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Assert for LByteToFloatFunction.
LByteToFloatFunctionXAssert<S extends LByteToFloatFunctionXAssert<S,A,RS,X>,A extends LByteToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Assert for LByteToFloatFunctionX.
LByteToIntFunctionAssert<S extends LByteToIntFunctionAssert<S,A,RS>,A extends LByteToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Assert for LByteToIntFunction.
LByteToIntFunctionXAssert<S extends LByteToIntFunctionXAssert<S,A,RS,X>,A extends LByteToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Assert for LByteToIntFunctionX.
LByteToLongFunctionAssert<S extends LByteToLongFunctionAssert<S,A,RS>,A extends LByteToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Assert for LByteToLongFunction.
LByteToLongFunctionXAssert<S extends LByteToLongFunctionXAssert<S,A,RS,X>,A extends LByteToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Assert for LByteToLongFunctionX.
LByteToShortFunctionAssert<S extends LByteToShortFunctionAssert<S,A,RS>,A extends LByteToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Assert for LByteToShortFunction.
LByteToShortFunctionXAssert<S extends LByteToShortFunctionXAssert<S,A,RS,X>,A extends LByteToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Assert for LByteToShortFunctionX.
LCharToByteFunctionAssert<S extends LCharToByteFunctionAssert<S,A,RS>,A extends LCharToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Assert for LCharToByteFunction.
LCharToByteFunctionXAssert<S extends LCharToByteFunctionXAssert<S,A,RS,X>,A extends LCharToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Assert for LCharToByteFunctionX.
LCharToDoubleFunctionAssert<S extends LCharToDoubleFunctionAssert<S,A,RS>,A extends LCharToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Assert for LCharToDoubleFunction.
LCharToDoubleFunctionXAssert<S extends LCharToDoubleFunctionXAssert<S,A,RS,X>,A extends LCharToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Assert for LCharToDoubleFunctionX.
LCharToFloatFunctionAssert<S extends LCharToFloatFunctionAssert<S,A,RS>,A extends LCharToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Assert for LCharToFloatFunction.
LCharToFloatFunctionXAssert<S extends LCharToFloatFunctionXAssert<S,A,RS,X>,A extends LCharToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Assert for LCharToFloatFunctionX.
LCharToIntFunctionAssert<S extends LCharToIntFunctionAssert<S,A,RS>,A extends LCharToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Assert for LCharToIntFunction.
LCharToIntFunctionXAssert<S extends LCharToIntFunctionXAssert<S,A,RS,X>,A extends LCharToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Assert for LCharToIntFunctionX.
LCharToLongFunctionAssert<S extends LCharToLongFunctionAssert<S,A,RS>,A extends LCharToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Assert for LCharToLongFunction.
LCharToLongFunctionXAssert<S extends LCharToLongFunctionXAssert<S,A,RS,X>,A extends LCharToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Assert for LCharToLongFunctionX.
LCharToShortFunctionAssert<S extends LCharToShortFunctionAssert<S,A,RS>,A extends LCharToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Assert for LCharToShortFunction.
LCharToShortFunctionXAssert<S extends LCharToShortFunctionXAssert<S,A,RS,X>,A extends LCharToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Assert for LCharToShortFunctionX.
LDoubleToByteFunctionAssert<S extends LDoubleToByteFunctionAssert<S,A,RS>,A extends LDoubleToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Assert for LDoubleToByteFunction.
LDoubleToByteFunctionXAssert<S extends LDoubleToByteFunctionXAssert<S,A,RS,X>,A extends LDoubleToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Assert for LDoubleToByteFunctionX.
LDoubleToCharFunctionAssert<S extends LDoubleToCharFunctionAssert<S,A,RS>,A extends LDoubleToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Assert for LDoubleToCharFunction.
LDoubleToCharFunctionXAssert<S extends LDoubleToCharFunctionXAssert<S,A,RS,X>,A extends LDoubleToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Assert for LDoubleToCharFunctionX.
LDoubleToFloatFunctionAssert<S extends LDoubleToFloatFunctionAssert<S,A,RS>,A extends LDoubleToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Assert for LDoubleToFloatFunction.
LDoubleToFloatFunctionXAssert<S extends LDoubleToFloatFunctionXAssert<S,A,RS,X>,A extends LDoubleToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Assert for LDoubleToFloatFunctionX.
LDoubleToIntFunctionAssert<S extends LDoubleToIntFunctionAssert<S,A,RS>,A extends LDoubleToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Assert for LDoubleToIntFunction.
LDoubleToIntFunctionXAssert<S extends LDoubleToIntFunctionXAssert<S,A,RS,X>,A extends LDoubleToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Assert for LDoubleToIntFunctionX.
LDoubleToLongFunctionAssert<S extends LDoubleToLongFunctionAssert<S,A,RS>,A extends LDoubleToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Assert for LDoubleToLongFunction.
LDoubleToLongFunctionXAssert<S extends LDoubleToLongFunctionXAssert<S,A,RS,X>,A extends LDoubleToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Assert for LDoubleToLongFunctionX.
LDoubleToShortFunctionAssert<S extends LDoubleToShortFunctionAssert<S,A,RS>,A extends LDoubleToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Assert for LDoubleToShortFunction.
LDoubleToShortFunctionXAssert<S extends LDoubleToShortFunctionXAssert<S,A,RS,X>,A extends LDoubleToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Assert for LDoubleToShortFunctionX.
LFloatToByteFunctionAssert<S extends LFloatToByteFunctionAssert<S,A,RS>,A extends LFloatToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Assert for LFloatToByteFunction.
LFloatToByteFunctionXAssert<S extends LFloatToByteFunctionXAssert<S,A,RS,X>,A extends LFloatToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Assert for LFloatToByteFunctionX.
LFloatToCharFunctionAssert<S extends LFloatToCharFunctionAssert<S,A,RS>,A extends LFloatToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Assert for LFloatToCharFunction.
LFloatToCharFunctionXAssert<S extends LFloatToCharFunctionXAssert<S,A,RS,X>,A extends LFloatToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Assert for LFloatToCharFunctionX.
LFloatToDoubleFunctionAssert<S extends LFloatToDoubleFunctionAssert<S,A,RS>,A extends LFloatToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Assert for LFloatToDoubleFunction.
LFloatToDoubleFunctionXAssert<S extends LFloatToDoubleFunctionXAssert<S,A,RS,X>,A extends LFloatToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Assert for LFloatToDoubleFunctionX.
LFloatToIntFunctionAssert<S extends LFloatToIntFunctionAssert<S,A,RS>,A extends LFloatToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Assert for LFloatToIntFunction.
LFloatToIntFunctionXAssert<S extends LFloatToIntFunctionXAssert<S,A,RS,X>,A extends LFloatToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Assert for LFloatToIntFunctionX.
LFloatToLongFunctionAssert<S extends LFloatToLongFunctionAssert<S,A,RS>,A extends LFloatToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Assert for LFloatToLongFunction.
LFloatToLongFunctionXAssert<S extends LFloatToLongFunctionXAssert<S,A,RS,X>,A extends LFloatToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Assert for LFloatToLongFunctionX.
LFloatToShortFunctionAssert<S extends LFloatToShortFunctionAssert<S,A,RS>,A extends LFloatToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Assert for LFloatToShortFunction.
LFloatToShortFunctionXAssert<S extends LFloatToShortFunctionXAssert<S,A,RS,X>,A extends LFloatToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Assert for LFloatToShortFunctionX.
LIntToByteFunctionAssert<S extends LIntToByteFunctionAssert<S,A,RS>,A extends LIntToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Assert for LIntToByteFunction.
LIntToByteFunctionXAssert<S extends LIntToByteFunctionXAssert<S,A,RS,X>,A extends LIntToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Assert for LIntToByteFunctionX.
LIntToCharFunctionAssert<S extends LIntToCharFunctionAssert<S,A,RS>,A extends LIntToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Assert for LIntToCharFunction.
LIntToCharFunctionXAssert<S extends LIntToCharFunctionXAssert<S,A,RS,X>,A extends LIntToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Assert for LIntToCharFunctionX.
LIntToDoubleFunctionAssert<S extends LIntToDoubleFunctionAssert<S,A,RS>,A extends LIntToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Assert for LIntToDoubleFunction.
LIntToDoubleFunctionXAssert<S extends LIntToDoubleFunctionXAssert<S,A,RS,X>,A extends LIntToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Assert for LIntToDoubleFunctionX.
LIntToFloatFunctionAssert<S extends LIntToFloatFunctionAssert<S,A,RS>,A extends LIntToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Assert for LIntToFloatFunction.
LIntToFloatFunctionXAssert<S extends LIntToFloatFunctionXAssert<S,A,RS,X>,A extends LIntToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Assert for LIntToFloatFunctionX.
LIntToLongFunctionAssert<S extends LIntToLongFunctionAssert<S,A,RS>,A extends LIntToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Assert for LIntToLongFunction.
LIntToLongFunctionXAssert<S extends LIntToLongFunctionXAssert<S,A,RS,X>,A extends LIntToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Assert for LIntToLongFunctionX.
LIntToShortFunctionAssert<S extends LIntToShortFunctionAssert<S,A,RS>,A extends LIntToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Assert for LIntToShortFunction.
LIntToShortFunctionXAssert<S extends LIntToShortFunctionXAssert<S,A,RS,X>,A extends LIntToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Assert for LIntToShortFunctionX.
LLongToByteFunctionAssert<S extends LLongToByteFunctionAssert<S,A,RS>,A extends LLongToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Assert for LLongToByteFunction.
LLongToByteFunctionXAssert<S extends LLongToByteFunctionXAssert<S,A,RS,X>,A extends LLongToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Assert for LLongToByteFunctionX.
LLongToCharFunctionAssert<S extends LLongToCharFunctionAssert<S,A,RS>,A extends LLongToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Assert for LLongToCharFunction.
LLongToCharFunctionXAssert<S extends LLongToCharFunctionXAssert<S,A,RS,X>,A extends LLongToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Assert for LLongToCharFunctionX.
LLongToDoubleFunctionAssert<S extends LLongToDoubleFunctionAssert<S,A,RS>,A extends LLongToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Assert for LLongToDoubleFunction.
LLongToDoubleFunctionXAssert<S extends LLongToDoubleFunctionXAssert<S,A,RS,X>,A extends LLongToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Assert for LLongToDoubleFunctionX.
LLongToFloatFunctionAssert<S extends LLongToFloatFunctionAssert<S,A,RS>,A extends LLongToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Assert for LLongToFloatFunction.
LLongToFloatFunctionXAssert<S extends LLongToFloatFunctionXAssert<S,A,RS,X>,A extends LLongToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Assert for LLongToFloatFunctionX.
LLongToIntFunctionAssert<S extends LLongToIntFunctionAssert<S,A,RS>,A extends LLongToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Assert for LLongToIntFunction.
LLongToIntFunctionXAssert<S extends LLongToIntFunctionXAssert<S,A,RS,X>,A extends LLongToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Assert for LLongToIntFunctionX.
LLongToShortFunctionAssert<S extends LLongToShortFunctionAssert<S,A,RS>,A extends LLongToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Assert for LLongToShortFunction.
LLongToShortFunctionXAssert<S extends LLongToShortFunctionXAssert<S,A,RS,X>,A extends LLongToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Assert for LLongToShortFunctionX.
LShortToByteFunctionAssert<S extends LShortToByteFunctionAssert<S,A,RS>,A extends LShortToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Assert for LShortToByteFunction.
LShortToByteFunctionXAssert<S extends LShortToByteFunctionXAssert<S,A,RS,X>,A extends LShortToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Assert for LShortToByteFunctionX.
LShortToCharFunctionAssert<S extends LShortToCharFunctionAssert<S,A,RS>,A extends LShortToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Assert for LShortToCharFunction.
LShortToCharFunctionXAssert<S extends LShortToCharFunctionXAssert<S,A,RS,X>,A extends LShortToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Assert for LShortToCharFunctionX.
LShortToDoubleFunctionAssert<S extends LShortToDoubleFunctionAssert<S,A,RS>,A extends LShortToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Assert for LShortToDoubleFunction.
LShortToDoubleFunctionXAssert<S extends LShortToDoubleFunctionXAssert<S,A,RS,X>,A extends LShortToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Assert for LShortToDoubleFunctionX.
LShortToFloatFunctionAssert<S extends LShortToFloatFunctionAssert<S,A,RS>,A extends LShortToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Assert for LShortToFloatFunction.
LShortToFloatFunctionXAssert<S extends LShortToFloatFunctionXAssert<S,A,RS,X>,A extends LShortToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Assert for LShortToFloatFunctionX.
LShortToIntFunctionAssert<S extends LShortToIntFunctionAssert<S,A,RS>,A extends LShortToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Assert for LShortToIntFunction.
LShortToIntFunctionXAssert<S extends LShortToIntFunctionXAssert<S,A,RS,X>,A extends LShortToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Assert for LShortToIntFunctionX.
LShortToLongFunctionAssert<S extends LShortToLongFunctionAssert<S,A,RS>,A extends LShortToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Assert for LShortToLongFunction.
LShortToLongFunctionXAssert<S extends LShortToLongFunctionXAssert<S,A,RS,X>,A extends LShortToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Assert for LShortToLongFunctionX.

Class Summary

Class	Description
LBoolToByteFunctionAssert.Base<S extends LBoolToByteFunctionAssert.Base<S,A,RS>,A extends LBoolToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Base implementation.
LBoolToByteFunctionAssert.The<A extends LBoolToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBoolToByteFunctionXAssert.Base<S extends LBoolToByteFunctionXAssert.Base<S,A,RS,X>,A extends LBoolToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Base implementation.
LBoolToByteFunctionXAssert.The<A extends LBoolToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBoolToCharFunctionAssert.Base<S extends LBoolToCharFunctionAssert.Base<S,A,RS>,A extends LBoolToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Base implementation.
LBoolToCharFunctionAssert.The<A extends LBoolToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBoolToCharFunctionXAssert.Base<S extends LBoolToCharFunctionXAssert.Base<S,A,RS,X>,A extends LBoolToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Base implementation.
LBoolToCharFunctionXAssert.The<A extends LBoolToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBoolToDoubleFunctionAssert.Base<S extends LBoolToDoubleFunctionAssert.Base<S,A,RS>,A extends LBoolToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Base implementation.
LBoolToDoubleFunctionAssert.The<A extends LBoolToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBoolToDoubleFunctionXAssert.Base<S extends LBoolToDoubleFunctionXAssert.Base<S,A,RS,X>,A extends LBoolToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Base implementation.
LBoolToDoubleFunctionXAssert.The<A extends LBoolToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBoolToFloatFunctionAssert.Base<S extends LBoolToFloatFunctionAssert.Base<S,A,RS>,A extends LBoolToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Base implementation.
LBoolToFloatFunctionAssert.The<A extends LBoolToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBoolToFloatFunctionXAssert.Base<S extends LBoolToFloatFunctionXAssert.Base<S,A,RS,X>,A extends LBoolToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Base implementation.
LBoolToFloatFunctionXAssert.The<A extends LBoolToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBoolToIntFunctionAssert.Base<S extends LBoolToIntFunctionAssert.Base<S,A,RS>,A extends LBoolToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Base implementation.
LBoolToIntFunctionAssert.The<A extends LBoolToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBoolToIntFunctionXAssert.Base<S extends LBoolToIntFunctionXAssert.Base<S,A,RS,X>,A extends LBoolToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Base implementation.
LBoolToIntFunctionXAssert.The<A extends LBoolToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBoolToLongFunctionAssert.Base<S extends LBoolToLongFunctionAssert.Base<S,A,RS>,A extends LBoolToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Base implementation.
LBoolToLongFunctionAssert.The<A extends LBoolToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBoolToLongFunctionXAssert.Base<S extends LBoolToLongFunctionXAssert.Base<S,A,RS,X>,A extends LBoolToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Base implementation.
LBoolToLongFunctionXAssert.The<A extends LBoolToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBoolToShortFunctionAssert.Base<S extends LBoolToShortFunctionAssert.Base<S,A,RS>,A extends LBoolToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Base implementation.
LBoolToShortFunctionAssert.The<A extends LBoolToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LBoolToShortFunctionXAssert.Base<S extends LBoolToShortFunctionXAssert.Base<S,A,RS,X>,A extends LBoolToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Base implementation.
LBoolToShortFunctionXAssert.The<A extends LBoolToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LByteToCharFunctionAssert.Base<S extends LByteToCharFunctionAssert.Base<S,A,RS>,A extends LByteToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Base implementation.
LByteToCharFunctionAssert.The<A extends LByteToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LByteToCharFunctionXAssert.Base<S extends LByteToCharFunctionXAssert.Base<S,A,RS,X>,A extends LByteToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Base implementation.
LByteToCharFunctionXAssert.The<A extends LByteToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LByteToDoubleFunctionAssert.Base<S extends LByteToDoubleFunctionAssert.Base<S,A,RS>,A extends LByteToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Base implementation.
LByteToDoubleFunctionAssert.The<A extends LByteToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LByteToDoubleFunctionXAssert.Base<S extends LByteToDoubleFunctionXAssert.Base<S,A,RS,X>,A extends LByteToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Base implementation.
LByteToDoubleFunctionXAssert.The<A extends LByteToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LByteToFloatFunctionAssert.Base<S extends LByteToFloatFunctionAssert.Base<S,A,RS>,A extends LByteToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Base implementation.
LByteToFloatFunctionAssert.The<A extends LByteToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LByteToFloatFunctionXAssert.Base<S extends LByteToFloatFunctionXAssert.Base<S,A,RS,X>,A extends LByteToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Base implementation.
LByteToFloatFunctionXAssert.The<A extends LByteToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LByteToIntFunctionAssert.Base<S extends LByteToIntFunctionAssert.Base<S,A,RS>,A extends LByteToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Base implementation.
LByteToIntFunctionAssert.The<A extends LByteToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LByteToIntFunctionXAssert.Base<S extends LByteToIntFunctionXAssert.Base<S,A,RS,X>,A extends LByteToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Base implementation.
LByteToIntFunctionXAssert.The<A extends LByteToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LByteToLongFunctionAssert.Base<S extends LByteToLongFunctionAssert.Base<S,A,RS>,A extends LByteToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Base implementation.
LByteToLongFunctionAssert.The<A extends LByteToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LByteToLongFunctionXAssert.Base<S extends LByteToLongFunctionXAssert.Base<S,A,RS,X>,A extends LByteToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Base implementation.
LByteToLongFunctionXAssert.The<A extends LByteToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LByteToShortFunctionAssert.Base<S extends LByteToShortFunctionAssert.Base<S,A,RS>,A extends LByteToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Base implementation.
LByteToShortFunctionAssert.The<A extends LByteToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LByteToShortFunctionXAssert.Base<S extends LByteToShortFunctionXAssert.Base<S,A,RS,X>,A extends LByteToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Base implementation.
LByteToShortFunctionXAssert.The<A extends LByteToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LCharToByteFunctionAssert.Base<S extends LCharToByteFunctionAssert.Base<S,A,RS>,A extends LCharToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Base implementation.
LCharToByteFunctionAssert.The<A extends LCharToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LCharToByteFunctionXAssert.Base<S extends LCharToByteFunctionXAssert.Base<S,A,RS,X>,A extends LCharToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Base implementation.
LCharToByteFunctionXAssert.The<A extends LCharToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LCharToDoubleFunctionAssert.Base<S extends LCharToDoubleFunctionAssert.Base<S,A,RS>,A extends LCharToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Base implementation.
LCharToDoubleFunctionAssert.The<A extends LCharToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LCharToDoubleFunctionXAssert.Base<S extends LCharToDoubleFunctionXAssert.Base<S,A,RS,X>,A extends LCharToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Base implementation.
LCharToDoubleFunctionXAssert.The<A extends LCharToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LCharToFloatFunctionAssert.Base<S extends LCharToFloatFunctionAssert.Base<S,A,RS>,A extends LCharToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Base implementation.
LCharToFloatFunctionAssert.The<A extends LCharToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LCharToFloatFunctionXAssert.Base<S extends LCharToFloatFunctionXAssert.Base<S,A,RS,X>,A extends LCharToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Base implementation.
LCharToFloatFunctionXAssert.The<A extends LCharToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LCharToIntFunctionAssert.Base<S extends LCharToIntFunctionAssert.Base<S,A,RS>,A extends LCharToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Base implementation.
LCharToIntFunctionAssert.The<A extends LCharToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LCharToIntFunctionXAssert.Base<S extends LCharToIntFunctionXAssert.Base<S,A,RS,X>,A extends LCharToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Base implementation.
LCharToIntFunctionXAssert.The<A extends LCharToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LCharToLongFunctionAssert.Base<S extends LCharToLongFunctionAssert.Base<S,A,RS>,A extends LCharToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Base implementation.
LCharToLongFunctionAssert.The<A extends LCharToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LCharToLongFunctionXAssert.Base<S extends LCharToLongFunctionXAssert.Base<S,A,RS,X>,A extends LCharToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Base implementation.
LCharToLongFunctionXAssert.The<A extends LCharToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LCharToShortFunctionAssert.Base<S extends LCharToShortFunctionAssert.Base<S,A,RS>,A extends LCharToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Base implementation.
LCharToShortFunctionAssert.The<A extends LCharToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LCharToShortFunctionXAssert.Base<S extends LCharToShortFunctionXAssert.Base<S,A,RS,X>,A extends LCharToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Base implementation.
LCharToShortFunctionXAssert.The<A extends LCharToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LDoubleToByteFunctionAssert.Base<S extends LDoubleToByteFunctionAssert.Base<S,A,RS>,A extends LDoubleToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Base implementation.
LDoubleToByteFunctionAssert.The<A extends LDoubleToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LDoubleToByteFunctionXAssert.Base<S extends LDoubleToByteFunctionXAssert.Base<S,A,RS,X>,A extends LDoubleToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Base implementation.
LDoubleToByteFunctionXAssert.The<A extends LDoubleToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LDoubleToCharFunctionAssert.Base<S extends LDoubleToCharFunctionAssert.Base<S,A,RS>,A extends LDoubleToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Base implementation.
LDoubleToCharFunctionAssert.The<A extends LDoubleToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LDoubleToCharFunctionXAssert.Base<S extends LDoubleToCharFunctionXAssert.Base<S,A,RS,X>,A extends LDoubleToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Base implementation.
LDoubleToCharFunctionXAssert.The<A extends LDoubleToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LDoubleToFloatFunctionAssert.Base<S extends LDoubleToFloatFunctionAssert.Base<S,A,RS>,A extends LDoubleToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Base implementation.
LDoubleToFloatFunctionAssert.The<A extends LDoubleToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LDoubleToFloatFunctionXAssert.Base<S extends LDoubleToFloatFunctionXAssert.Base<S,A,RS,X>,A extends LDoubleToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Base implementation.
LDoubleToFloatFunctionXAssert.The<A extends LDoubleToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LDoubleToIntFunctionAssert.Base<S extends LDoubleToIntFunctionAssert.Base<S,A,RS>,A extends LDoubleToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Base implementation.
LDoubleToIntFunctionAssert.The<A extends LDoubleToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LDoubleToIntFunctionXAssert.Base<S extends LDoubleToIntFunctionXAssert.Base<S,A,RS,X>,A extends LDoubleToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Base implementation.
LDoubleToIntFunctionXAssert.The<A extends LDoubleToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LDoubleToLongFunctionAssert.Base<S extends LDoubleToLongFunctionAssert.Base<S,A,RS>,A extends LDoubleToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Base implementation.
LDoubleToLongFunctionAssert.The<A extends LDoubleToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LDoubleToLongFunctionXAssert.Base<S extends LDoubleToLongFunctionXAssert.Base<S,A,RS,X>,A extends LDoubleToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Base implementation.
LDoubleToLongFunctionXAssert.The<A extends LDoubleToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LDoubleToShortFunctionAssert.Base<S extends LDoubleToShortFunctionAssert.Base<S,A,RS>,A extends LDoubleToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Base implementation.
LDoubleToShortFunctionAssert.The<A extends LDoubleToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LDoubleToShortFunctionXAssert.Base<S extends LDoubleToShortFunctionXAssert.Base<S,A,RS,X>,A extends LDoubleToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Base implementation.
LDoubleToShortFunctionXAssert.The<A extends LDoubleToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LFloatToByteFunctionAssert.Base<S extends LFloatToByteFunctionAssert.Base<S,A,RS>,A extends LFloatToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Base implementation.
LFloatToByteFunctionAssert.The<A extends LFloatToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LFloatToByteFunctionXAssert.Base<S extends LFloatToByteFunctionXAssert.Base<S,A,RS,X>,A extends LFloatToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Base implementation.
LFloatToByteFunctionXAssert.The<A extends LFloatToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LFloatToCharFunctionAssert.Base<S extends LFloatToCharFunctionAssert.Base<S,A,RS>,A extends LFloatToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Base implementation.
LFloatToCharFunctionAssert.The<A extends LFloatToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LFloatToCharFunctionXAssert.Base<S extends LFloatToCharFunctionXAssert.Base<S,A,RS,X>,A extends LFloatToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Base implementation.
LFloatToCharFunctionXAssert.The<A extends LFloatToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LFloatToDoubleFunctionAssert.Base<S extends LFloatToDoubleFunctionAssert.Base<S,A,RS>,A extends LFloatToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Base implementation.
LFloatToDoubleFunctionAssert.The<A extends LFloatToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LFloatToDoubleFunctionXAssert.Base<S extends LFloatToDoubleFunctionXAssert.Base<S,A,RS,X>,A extends LFloatToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Base implementation.
LFloatToDoubleFunctionXAssert.The<A extends LFloatToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LFloatToIntFunctionAssert.Base<S extends LFloatToIntFunctionAssert.Base<S,A,RS>,A extends LFloatToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Base implementation.
LFloatToIntFunctionAssert.The<A extends LFloatToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LFloatToIntFunctionXAssert.Base<S extends LFloatToIntFunctionXAssert.Base<S,A,RS,X>,A extends LFloatToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Base implementation.
LFloatToIntFunctionXAssert.The<A extends LFloatToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LFloatToLongFunctionAssert.Base<S extends LFloatToLongFunctionAssert.Base<S,A,RS>,A extends LFloatToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Base implementation.
LFloatToLongFunctionAssert.The<A extends LFloatToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LFloatToLongFunctionXAssert.Base<S extends LFloatToLongFunctionXAssert.Base<S,A,RS,X>,A extends LFloatToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Base implementation.
LFloatToLongFunctionXAssert.The<A extends LFloatToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LFloatToShortFunctionAssert.Base<S extends LFloatToShortFunctionAssert.Base<S,A,RS>,A extends LFloatToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Base implementation.
LFloatToShortFunctionAssert.The<A extends LFloatToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LFloatToShortFunctionXAssert.Base<S extends LFloatToShortFunctionXAssert.Base<S,A,RS,X>,A extends LFloatToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Base implementation.
LFloatToShortFunctionXAssert.The<A extends LFloatToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LIntToByteFunctionAssert.Base<S extends LIntToByteFunctionAssert.Base<S,A,RS>,A extends LIntToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Base implementation.
LIntToByteFunctionAssert.The<A extends LIntToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LIntToByteFunctionXAssert.Base<S extends LIntToByteFunctionXAssert.Base<S,A,RS,X>,A extends LIntToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Base implementation.
LIntToByteFunctionXAssert.The<A extends LIntToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LIntToCharFunctionAssert.Base<S extends LIntToCharFunctionAssert.Base<S,A,RS>,A extends LIntToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Base implementation.
LIntToCharFunctionAssert.The<A extends LIntToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LIntToCharFunctionXAssert.Base<S extends LIntToCharFunctionXAssert.Base<S,A,RS,X>,A extends LIntToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Base implementation.
LIntToCharFunctionXAssert.The<A extends LIntToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LIntToDoubleFunctionAssert.Base<S extends LIntToDoubleFunctionAssert.Base<S,A,RS>,A extends LIntToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Base implementation.
LIntToDoubleFunctionAssert.The<A extends LIntToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LIntToDoubleFunctionXAssert.Base<S extends LIntToDoubleFunctionXAssert.Base<S,A,RS,X>,A extends LIntToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Base implementation.
LIntToDoubleFunctionXAssert.The<A extends LIntToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LIntToFloatFunctionAssert.Base<S extends LIntToFloatFunctionAssert.Base<S,A,RS>,A extends LIntToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Base implementation.
LIntToFloatFunctionAssert.The<A extends LIntToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LIntToFloatFunctionXAssert.Base<S extends LIntToFloatFunctionXAssert.Base<S,A,RS,X>,A extends LIntToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Base implementation.
LIntToFloatFunctionXAssert.The<A extends LIntToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LIntToLongFunctionAssert.Base<S extends LIntToLongFunctionAssert.Base<S,A,RS>,A extends LIntToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Base implementation.
LIntToLongFunctionAssert.The<A extends LIntToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LIntToLongFunctionXAssert.Base<S extends LIntToLongFunctionXAssert.Base<S,A,RS,X>,A extends LIntToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Base implementation.
LIntToLongFunctionXAssert.The<A extends LIntToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LIntToShortFunctionAssert.Base<S extends LIntToShortFunctionAssert.Base<S,A,RS>,A extends LIntToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Base implementation.
LIntToShortFunctionAssert.The<A extends LIntToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LIntToShortFunctionXAssert.Base<S extends LIntToShortFunctionXAssert.Base<S,A,RS,X>,A extends LIntToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Base implementation.
LIntToShortFunctionXAssert.The<A extends LIntToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LLongToByteFunctionAssert.Base<S extends LLongToByteFunctionAssert.Base<S,A,RS>,A extends LLongToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Base implementation.
LLongToByteFunctionAssert.The<A extends LLongToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LLongToByteFunctionXAssert.Base<S extends LLongToByteFunctionXAssert.Base<S,A,RS,X>,A extends LLongToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Base implementation.
LLongToByteFunctionXAssert.The<A extends LLongToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LLongToCharFunctionAssert.Base<S extends LLongToCharFunctionAssert.Base<S,A,RS>,A extends LLongToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Base implementation.
LLongToCharFunctionAssert.The<A extends LLongToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LLongToCharFunctionXAssert.Base<S extends LLongToCharFunctionXAssert.Base<S,A,RS,X>,A extends LLongToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Base implementation.
LLongToCharFunctionXAssert.The<A extends LLongToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LLongToDoubleFunctionAssert.Base<S extends LLongToDoubleFunctionAssert.Base<S,A,RS>,A extends LLongToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Base implementation.
LLongToDoubleFunctionAssert.The<A extends LLongToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LLongToDoubleFunctionXAssert.Base<S extends LLongToDoubleFunctionXAssert.Base<S,A,RS,X>,A extends LLongToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Base implementation.
LLongToDoubleFunctionXAssert.The<A extends LLongToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LLongToFloatFunctionAssert.Base<S extends LLongToFloatFunctionAssert.Base<S,A,RS>,A extends LLongToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Base implementation.
LLongToFloatFunctionAssert.The<A extends LLongToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LLongToFloatFunctionXAssert.Base<S extends LLongToFloatFunctionXAssert.Base<S,A,RS,X>,A extends LLongToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Base implementation.
LLongToFloatFunctionXAssert.The<A extends LLongToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LLongToIntFunctionAssert.Base<S extends LLongToIntFunctionAssert.Base<S,A,RS>,A extends LLongToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Base implementation.
LLongToIntFunctionAssert.The<A extends LLongToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LLongToIntFunctionXAssert.Base<S extends LLongToIntFunctionXAssert.Base<S,A,RS,X>,A extends LLongToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Base implementation.
LLongToIntFunctionXAssert.The<A extends LLongToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LLongToShortFunctionAssert.Base<S extends LLongToShortFunctionAssert.Base<S,A,RS>,A extends LLongToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Base implementation.
LLongToShortFunctionAssert.The<A extends LLongToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LLongToShortFunctionXAssert.Base<S extends LLongToShortFunctionXAssert.Base<S,A,RS,X>,A extends LLongToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Base implementation.
LLongToShortFunctionXAssert.The<A extends LLongToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LShortToByteFunctionAssert.Base<S extends LShortToByteFunctionAssert.Base<S,A,RS>,A extends LShortToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Base implementation.
LShortToByteFunctionAssert.The<A extends LShortToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LShortToByteFunctionXAssert.Base<S extends LShortToByteFunctionXAssert.Base<S,A,RS,X>,A extends LShortToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Base implementation.
LShortToByteFunctionXAssert.The<A extends LShortToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LShortToCharFunctionAssert.Base<S extends LShortToCharFunctionAssert.Base<S,A,RS>,A extends LShortToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Base implementation.
LShortToCharFunctionAssert.The<A extends LShortToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LShortToCharFunctionXAssert.Base<S extends LShortToCharFunctionXAssert.Base<S,A,RS,X>,A extends LShortToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Base implementation.
LShortToCharFunctionXAssert.The<A extends LShortToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LShortToDoubleFunctionAssert.Base<S extends LShortToDoubleFunctionAssert.Base<S,A,RS>,A extends LShortToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Base implementation.
LShortToDoubleFunctionAssert.The<A extends LShortToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LShortToDoubleFunctionXAssert.Base<S extends LShortToDoubleFunctionXAssert.Base<S,A,RS,X>,A extends LShortToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Base implementation.
LShortToDoubleFunctionXAssert.The<A extends LShortToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LShortToFloatFunctionAssert.Base<S extends LShortToFloatFunctionAssert.Base<S,A,RS>,A extends LShortToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Base implementation.
LShortToFloatFunctionAssert.The<A extends LShortToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LShortToFloatFunctionXAssert.Base<S extends LShortToFloatFunctionXAssert.Base<S,A,RS,X>,A extends LShortToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Base implementation.
LShortToFloatFunctionXAssert.The<A extends LShortToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LShortToIntFunctionAssert.Base<S extends LShortToIntFunctionAssert.Base<S,A,RS>,A extends LShortToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Base implementation.
LShortToIntFunctionAssert.The<A extends LShortToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LShortToIntFunctionXAssert.Base<S extends LShortToIntFunctionXAssert.Base<S,A,RS,X>,A extends LShortToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Base implementation.
LShortToIntFunctionXAssert.The<A extends LShortToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LShortToLongFunctionAssert.Base<S extends LShortToLongFunctionAssert.Base<S,A,RS>,A extends LShortToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Base implementation.
LShortToLongFunctionAssert.The<A extends LShortToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).
LShortToLongFunctionXAssert.Base<S extends LShortToLongFunctionXAssert.Base<S,A,RS,X>,A extends LShortToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Base implementation.
LShortToLongFunctionXAssert.The<A extends LShortToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable>	Convenience implementation - if you want instantiate not to extend (uses one less generic parameter).