eu.lunisolar.magma.func.asserts

Interface FunctionalAssertions

public interface FunctionalAssertions

Default implementation of assertion factories. Always use with/by provided type argument OS otherwise compiler will not be able to infer the type of assertion class.

Method Summary

Modifier and Type	Method and Description
static <A extends java.util.function.BiConsumer<T1,T2>,T1,T2> BiConsumerAssert.The<A,T1,T2>	assertThat(java.util.function.BiConsumer<T1,T2> functionalInterface)
static <A extends java.util.function.BiFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> BiFunctionAssert.The<A,RS,T1,T2,R>	assertThat(java.util.function.BiFunction<T1,T2,R> functionalInterface)
static <A extends java.util.function.BinaryOperator<T>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,T>,T> BinaryOperatorAssert.The<A,RS,T>	assertThat(java.util.function.BinaryOperator<T> functionalInterface)
static <A extends java.util.function.BiPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> BiPredicateAssert.The<A,RS,T1,T2>	assertThat(java.util.function.BiPredicate<T1,T2> functionalInterface)
static <A extends java.util.function.BooleanSupplier,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> BooleanSupplierAssert.The<A,RS>	assertThat(java.util.function.BooleanSupplier functionalInterface)
static <A extends java.util.function.Consumer<T>,T> ConsumerAssert.The<A,T>	assertThat(java.util.function.Consumer<T> functionalInterface)
static <A extends java.util.function.DoubleBinaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> DoubleBinaryOperatorAssert.The<A,RS>	assertThat(java.util.function.DoubleBinaryOperator functionalInterface)
static <A extends java.util.function.DoubleConsumer> DoubleConsumerAssert.The<A>	assertThat(java.util.function.DoubleConsumer functionalInterface)
static <A extends java.util.function.DoubleFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> DoubleFunctionAssert.The<A,RS,R>	assertThat(java.util.function.DoubleFunction<R> functionalInterface)
static <A extends java.util.function.DoublePredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> DoublePredicateAssert.The<A,RS>	assertThat(java.util.function.DoublePredicate functionalInterface)
static <A extends java.util.function.DoubleSupplier,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> DoubleSupplierAssert.The<A,RS>	assertThat(java.util.function.DoubleSupplier functionalInterface)
static <A extends java.util.function.DoubleToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> DoubleToIntFunctionAssert.The<A,RS>	assertThat(java.util.function.DoubleToIntFunction functionalInterface)
static <A extends java.util.function.DoubleToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> DoubleToLongFunctionAssert.The<A,RS>	assertThat(java.util.function.DoubleToLongFunction functionalInterface)
static <A extends java.util.function.DoubleUnaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> DoubleUnaryOperatorAssert.The<A,RS>	assertThat(java.util.function.DoubleUnaryOperator functionalInterface)
static <A extends java.util.function.Function<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> FunctionAssert.The<A,RS,T,R>	assertThat(java.util.function.Function<T,R> functionalInterface)
static <A extends java.util.function.IntBinaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> IntBinaryOperatorAssert.The<A,RS>	assertThat(java.util.function.IntBinaryOperator functionalInterface)
static <A extends java.util.function.IntConsumer> IntConsumerAssert.The<A>	assertThat(java.util.function.IntConsumer functionalInterface)
static <A extends java.util.function.IntFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> IntFunctionAssert.The<A,RS,R>	assertThat(java.util.function.IntFunction<R> functionalInterface)
static <A extends java.util.function.IntPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> IntPredicateAssert.The<A,RS>	assertThat(java.util.function.IntPredicate functionalInterface)
static <A extends java.util.function.IntSupplier,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> IntSupplierAssert.The<A,RS>	assertThat(java.util.function.IntSupplier functionalInterface)
static <A extends java.util.function.IntToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> IntToDoubleFunctionAssert.The<A,RS>	assertThat(java.util.function.IntToDoubleFunction functionalInterface)
static <A extends java.util.function.IntToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> IntToLongFunctionAssert.The<A,RS>	assertThat(java.util.function.IntToLongFunction functionalInterface)
static <A extends java.util.function.IntUnaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> IntUnaryOperatorAssert.The<A,RS>	assertThat(java.util.function.IntUnaryOperator functionalInterface)
static <A extends LAction> LActionAssert.The<A>	assertThat(LAction functionalInterface)
static <A extends LActionX<X>,X extends Throwable> LActionXAssert.The<A,X>	assertThat(LActionX<X> functionalInterface)
static <A extends LBiBoolConsumer> LBiBoolConsumerAssert.The<A>	assertThat(LBiBoolConsumer functionalInterface)
static <A extends LBiBoolConsumerX<X>,X extends Throwable> LBiBoolConsumerXAssert.The<A,X>	assertThat(LBiBoolConsumerX<X> functionalInterface)
static <A extends LBiBoolFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBiBoolFunctionAssert.The<A,RS,R>	assertThat(LBiBoolFunction<R> functionalInterface)
static <A extends LBiBoolFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBiBoolFunctionXAssert.The<A,RS,R,X>	assertThat(LBiBoolFunctionX<R,X> functionalInterface)
static <A extends LBiByteConsumer> LBiByteConsumerAssert.The<A>	assertThat(LBiByteConsumer functionalInterface)
static <A extends LBiByteConsumerX<X>,X extends Throwable> LBiByteConsumerXAssert.The<A,X>	assertThat(LBiByteConsumerX<X> functionalInterface)
static <A extends LBiByteFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBiByteFunctionAssert.The<A,RS,R>	assertThat(LBiByteFunction<R> functionalInterface)
static <A extends LBiByteFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBiByteFunctionXAssert.The<A,RS,R,X>	assertThat(LBiByteFunctionX<R,X> functionalInterface)
static <A extends LBiBytePredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBiBytePredicateAssert.The<A,RS>	assertThat(LBiBytePredicate functionalInterface)
static <A extends LBiBytePredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBiBytePredicateXAssert.The<A,RS,X>	assertThat(LBiBytePredicateX<X> functionalInterface)
static <A extends LBiCharConsumer> LBiCharConsumerAssert.The<A>	assertThat(LBiCharConsumer functionalInterface)
static <A extends LBiCharConsumerX<X>,X extends Throwable> LBiCharConsumerXAssert.The<A,X>	assertThat(LBiCharConsumerX<X> functionalInterface)
static <A extends LBiCharFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBiCharFunctionAssert.The<A,RS,R>	assertThat(LBiCharFunction<R> functionalInterface)
static <A extends LBiCharFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBiCharFunctionXAssert.The<A,RS,R,X>	assertThat(LBiCharFunctionX<R,X> functionalInterface)
static <A extends LBiCharPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBiCharPredicateAssert.The<A,RS>	assertThat(LBiCharPredicate functionalInterface)
static <A extends LBiCharPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBiCharPredicateXAssert.The<A,RS,X>	assertThat(LBiCharPredicateX<X> functionalInterface)
static <A extends LBiConsumer<T1,T2>,T1,T2> LBiConsumerAssert.The<A,T1,T2>	assertThat(LBiConsumer<T1,T2> functionalInterface)
static <A extends LBiConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiConsumerXAssert.The<A,T1,T2,X>	assertThat(LBiConsumerX<T1,T2,X> functionalInterface)
static <A extends LBiDoubleConsumer> LBiDoubleConsumerAssert.The<A>	assertThat(LBiDoubleConsumer functionalInterface)
static <A extends LBiDoubleConsumerX<X>,X extends Throwable> LBiDoubleConsumerXAssert.The<A,X>	assertThat(LBiDoubleConsumerX<X> functionalInterface)
static <A extends LBiDoubleFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBiDoubleFunctionAssert.The<A,RS,R>	assertThat(LBiDoubleFunction<R> functionalInterface)
static <A extends LBiDoubleFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBiDoubleFunctionXAssert.The<A,RS,R,X>	assertThat(LBiDoubleFunctionX<R,X> functionalInterface)
static <A extends LBiDoublePredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBiDoublePredicateAssert.The<A,RS>	assertThat(LBiDoublePredicate functionalInterface)
static <A extends LBiDoublePredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBiDoublePredicateXAssert.The<A,RS,X>	assertThat(LBiDoublePredicateX<X> functionalInterface)
static <A extends LBiFloatConsumer> LBiFloatConsumerAssert.The<A>	assertThat(LBiFloatConsumer functionalInterface)
static <A extends LBiFloatConsumerX<X>,X extends Throwable> LBiFloatConsumerXAssert.The<A,X>	assertThat(LBiFloatConsumerX<X> functionalInterface)
static <A extends LBiFloatFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBiFloatFunctionAssert.The<A,RS,R>	assertThat(LBiFloatFunction<R> functionalInterface)
static <A extends LBiFloatFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBiFloatFunctionXAssert.The<A,RS,R,X>	assertThat(LBiFloatFunctionX<R,X> functionalInterface)
static <A extends LBiFloatPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBiFloatPredicateAssert.The<A,RS>	assertThat(LBiFloatPredicate functionalInterface)
static <A extends LBiFloatPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBiFloatPredicateXAssert.The<A,RS,X>	assertThat(LBiFloatPredicateX<X> functionalInterface)
static <A extends LBiFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiFunctionAssert.The<A,RS,T1,T2,R>	assertThat(LBiFunction<T1,T2,R> functionalInterface)
static <A extends LBiFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiFunctionXAssert.The<A,RS,T1,T2,R,X>	assertThat(LBiFunctionX<T1,T2,R,X> functionalInterface)
static <A extends LBiIntConsumer> LBiIntConsumerAssert.The<A>	assertThat(LBiIntConsumer functionalInterface)
static <A extends LBiIntConsumerX<X>,X extends Throwable> LBiIntConsumerXAssert.The<A,X>	assertThat(LBiIntConsumerX<X> functionalInterface)
static <A extends LBiIntFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBiIntFunctionAssert.The<A,RS,R>	assertThat(LBiIntFunction<R> functionalInterface)
static <A extends LBiIntFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBiIntFunctionXAssert.The<A,RS,R,X>	assertThat(LBiIntFunctionX<R,X> functionalInterface)
static <A extends LBiIntPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBiIntPredicateAssert.The<A,RS>	assertThat(LBiIntPredicate functionalInterface)
static <A extends LBiIntPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBiIntPredicateXAssert.The<A,RS,X>	assertThat(LBiIntPredicateX<X> functionalInterface)
static <A extends LBiLongConsumer> LBiLongConsumerAssert.The<A>	assertThat(LBiLongConsumer functionalInterface)
static <A extends LBiLongConsumerX<X>,X extends Throwable> LBiLongConsumerXAssert.The<A,X>	assertThat(LBiLongConsumerX<X> functionalInterface)
static <A extends LBiLongFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBiLongFunctionAssert.The<A,RS,R>	assertThat(LBiLongFunction<R> functionalInterface)
static <A extends LBiLongFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBiLongFunctionXAssert.The<A,RS,R,X>	assertThat(LBiLongFunctionX<R,X> functionalInterface)
static <A extends LBiLongPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBiLongPredicateAssert.The<A,RS>	assertThat(LBiLongPredicate functionalInterface)
static <A extends LBiLongPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBiLongPredicateXAssert.The<A,RS,X>	assertThat(LBiLongPredicateX<X> functionalInterface)
static <A extends LBinaryOperator<T>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,T>,T> LBinaryOperatorAssert.The<A,RS,T>	assertThat(LBinaryOperator<T> functionalInterface)
static <A extends LBinaryOperatorX<T,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,T>,T,X extends Throwable> LBinaryOperatorXAssert.The<A,RS,T,X>	assertThat(LBinaryOperatorX<T,X> functionalInterface)
static <A extends LBiObjBoolConsumer<T1,T2>,T1,T2> LBiObjBoolConsumerAssert.The<A,T1,T2>	assertThat(LBiObjBoolConsumer<T1,T2> functionalInterface)
static <A extends LBiObjBoolConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiObjBoolConsumerXAssert.The<A,T1,T2,X>	assertThat(LBiObjBoolConsumerX<T1,T2,X> functionalInterface)
static <A extends LBiObjBoolFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiObjBoolFunctionAssert.The<A,RS,T1,T2,R>	assertThat(LBiObjBoolFunction<T1,T2,R> functionalInterface)
static <A extends LBiObjBoolFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiObjBoolFunctionXAssert.The<A,RS,T1,T2,R,X>	assertThat(LBiObjBoolFunctionX<T1,T2,R,X> functionalInterface)
static <A extends LBiObjBoolPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiObjBoolPredicateAssert.The<A,RS,T1,T2>	assertThat(LBiObjBoolPredicate<T1,T2> functionalInterface)
static <A extends LBiObjBoolPredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiObjBoolPredicateXAssert.The<A,RS,T1,T2,X>	assertThat(LBiObjBoolPredicateX<T1,T2,X> functionalInterface)
static <A extends LBiObjByteConsumer<T1,T2>,T1,T2> LBiObjByteConsumerAssert.The<A,T1,T2>	assertThat(LBiObjByteConsumer<T1,T2> functionalInterface)
static <A extends LBiObjByteConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiObjByteConsumerXAssert.The<A,T1,T2,X>	assertThat(LBiObjByteConsumerX<T1,T2,X> functionalInterface)
static <A extends LBiObjByteFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiObjByteFunctionAssert.The<A,RS,T1,T2,R>	assertThat(LBiObjByteFunction<T1,T2,R> functionalInterface)
static <A extends LBiObjByteFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiObjByteFunctionXAssert.The<A,RS,T1,T2,R,X>	assertThat(LBiObjByteFunctionX<T1,T2,R,X> functionalInterface)
static <A extends LBiObjBytePredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiObjBytePredicateAssert.The<A,RS,T1,T2>	assertThat(LBiObjBytePredicate<T1,T2> functionalInterface)
static <A extends LBiObjBytePredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiObjBytePredicateXAssert.The<A,RS,T1,T2,X>	assertThat(LBiObjBytePredicateX<T1,T2,X> functionalInterface)
static <A extends LBiObjCharConsumer<T1,T2>,T1,T2> LBiObjCharConsumerAssert.The<A,T1,T2>	assertThat(LBiObjCharConsumer<T1,T2> functionalInterface)
static <A extends LBiObjCharConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiObjCharConsumerXAssert.The<A,T1,T2,X>	assertThat(LBiObjCharConsumerX<T1,T2,X> functionalInterface)
static <A extends LBiObjCharFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiObjCharFunctionAssert.The<A,RS,T1,T2,R>	assertThat(LBiObjCharFunction<T1,T2,R> functionalInterface)
static <A extends LBiObjCharFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiObjCharFunctionXAssert.The<A,RS,T1,T2,R,X>	assertThat(LBiObjCharFunctionX<T1,T2,R,X> functionalInterface)
static <A extends LBiObjCharPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiObjCharPredicateAssert.The<A,RS,T1,T2>	assertThat(LBiObjCharPredicate<T1,T2> functionalInterface)
static <A extends LBiObjCharPredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiObjCharPredicateXAssert.The<A,RS,T1,T2,X>	assertThat(LBiObjCharPredicateX<T1,T2,X> functionalInterface)
static <A extends LBiObjDoubleConsumer<T1,T2>,T1,T2> LBiObjDoubleConsumerAssert.The<A,T1,T2>	assertThat(LBiObjDoubleConsumer<T1,T2> functionalInterface)
static <A extends LBiObjDoubleConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiObjDoubleConsumerXAssert.The<A,T1,T2,X>	assertThat(LBiObjDoubleConsumerX<T1,T2,X> functionalInterface)
static <A extends LBiObjDoubleFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiObjDoubleFunctionAssert.The<A,RS,T1,T2,R>	assertThat(LBiObjDoubleFunction<T1,T2,R> functionalInterface)
static <A extends LBiObjDoubleFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiObjDoubleFunctionXAssert.The<A,RS,T1,T2,R,X>	assertThat(LBiObjDoubleFunctionX<T1,T2,R,X> functionalInterface)
static <A extends LBiObjDoublePredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiObjDoublePredicateAssert.The<A,RS,T1,T2>	assertThat(LBiObjDoublePredicate<T1,T2> functionalInterface)
static <A extends LBiObjDoublePredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiObjDoublePredicateXAssert.The<A,RS,T1,T2,X>	assertThat(LBiObjDoublePredicateX<T1,T2,X> functionalInterface)
static <A extends LBiObjFloatConsumer<T1,T2>,T1,T2> LBiObjFloatConsumerAssert.The<A,T1,T2>	assertThat(LBiObjFloatConsumer<T1,T2> functionalInterface)
static <A extends LBiObjFloatConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiObjFloatConsumerXAssert.The<A,T1,T2,X>	assertThat(LBiObjFloatConsumerX<T1,T2,X> functionalInterface)
static <A extends LBiObjFloatFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiObjFloatFunctionAssert.The<A,RS,T1,T2,R>	assertThat(LBiObjFloatFunction<T1,T2,R> functionalInterface)
static <A extends LBiObjFloatFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiObjFloatFunctionXAssert.The<A,RS,T1,T2,R,X>	assertThat(LBiObjFloatFunctionX<T1,T2,R,X> functionalInterface)
static <A extends LBiObjFloatPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiObjFloatPredicateAssert.The<A,RS,T1,T2>	assertThat(LBiObjFloatPredicate<T1,T2> functionalInterface)
static <A extends LBiObjFloatPredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiObjFloatPredicateXAssert.The<A,RS,T1,T2,X>	assertThat(LBiObjFloatPredicateX<T1,T2,X> functionalInterface)
static <A extends LBiObjIntConsumer<T1,T2>,T1,T2> LBiObjIntConsumerAssert.The<A,T1,T2>	assertThat(LBiObjIntConsumer<T1,T2> functionalInterface)
static <A extends LBiObjIntConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiObjIntConsumerXAssert.The<A,T1,T2,X>	assertThat(LBiObjIntConsumerX<T1,T2,X> functionalInterface)
static <A extends LBiObjIntFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiObjIntFunctionAssert.The<A,RS,T1,T2,R>	assertThat(LBiObjIntFunction<T1,T2,R> functionalInterface)
static <A extends LBiObjIntFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiObjIntFunctionXAssert.The<A,RS,T1,T2,R,X>	assertThat(LBiObjIntFunctionX<T1,T2,R,X> functionalInterface)
static <A extends LBiObjIntPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiObjIntPredicateAssert.The<A,RS,T1,T2>	assertThat(LBiObjIntPredicate<T1,T2> functionalInterface)
static <A extends LBiObjIntPredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiObjIntPredicateXAssert.The<A,RS,T1,T2,X>	assertThat(LBiObjIntPredicateX<T1,T2,X> functionalInterface)
static <A extends LBiObjLongConsumer<T1,T2>,T1,T2> LBiObjLongConsumerAssert.The<A,T1,T2>	assertThat(LBiObjLongConsumer<T1,T2> functionalInterface)
static <A extends LBiObjLongConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiObjLongConsumerXAssert.The<A,T1,T2,X>	assertThat(LBiObjLongConsumerX<T1,T2,X> functionalInterface)
static <A extends LBiObjLongFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiObjLongFunctionAssert.The<A,RS,T1,T2,R>	assertThat(LBiObjLongFunction<T1,T2,R> functionalInterface)
static <A extends LBiObjLongFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiObjLongFunctionXAssert.The<A,RS,T1,T2,R,X>	assertThat(LBiObjLongFunctionX<T1,T2,R,X> functionalInterface)
static <A extends LBiObjLongPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiObjLongPredicateAssert.The<A,RS,T1,T2>	assertThat(LBiObjLongPredicate<T1,T2> functionalInterface)
static <A extends LBiObjLongPredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiObjLongPredicateXAssert.The<A,RS,T1,T2,X>	assertThat(LBiObjLongPredicateX<T1,T2,X> functionalInterface)
static <A extends LBiObjShortConsumer<T1,T2>,T1,T2> LBiObjShortConsumerAssert.The<A,T1,T2>	assertThat(LBiObjShortConsumer<T1,T2> functionalInterface)
static <A extends LBiObjShortConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiObjShortConsumerXAssert.The<A,T1,T2,X>	assertThat(LBiObjShortConsumerX<T1,T2,X> functionalInterface)
static <A extends LBiObjShortFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiObjShortFunctionAssert.The<A,RS,T1,T2,R>	assertThat(LBiObjShortFunction<T1,T2,R> functionalInterface)
static <A extends LBiObjShortFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiObjShortFunctionXAssert.The<A,RS,T1,T2,R,X>	assertThat(LBiObjShortFunctionX<T1,T2,R,X> functionalInterface)
static <A extends LBiObjShortPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiObjShortPredicateAssert.The<A,RS,T1,T2>	assertThat(LBiObjShortPredicate<T1,T2> functionalInterface)
static <A extends LBiObjShortPredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiObjShortPredicateXAssert.The<A,RS,T1,T2,X>	assertThat(LBiObjShortPredicateX<T1,T2,X> functionalInterface)
static <A extends LBiPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiPredicateAssert.The<A,RS,T1,T2>	assertThat(LBiPredicate<T1,T2> functionalInterface)
static <A extends LBiPredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiPredicateXAssert.The<A,RS,T1,T2,X>	assertThat(LBiPredicateX<T1,T2,X> functionalInterface)
static <A extends LBiShortConsumer> LBiShortConsumerAssert.The<A>	assertThat(LBiShortConsumer functionalInterface)
static <A extends LBiShortConsumerX<X>,X extends Throwable> LBiShortConsumerXAssert.The<A,X>	assertThat(LBiShortConsumerX<X> functionalInterface)
static <A extends LBiShortFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBiShortFunctionAssert.The<A,RS,R>	assertThat(LBiShortFunction<R> functionalInterface)
static <A extends LBiShortFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBiShortFunctionXAssert.The<A,RS,R,X>	assertThat(LBiShortFunctionX<R,X> functionalInterface)
static <A extends LBiShortPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBiShortPredicateAssert.The<A,RS>	assertThat(LBiShortPredicate functionalInterface)
static <A extends LBiShortPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBiShortPredicateXAssert.The<A,RS,X>	assertThat(LBiShortPredicateX<X> functionalInterface)
static <A extends LBoolConsumer> LBoolConsumerAssert.The<A>	assertThat(LBoolConsumer functionalInterface)
static <A extends LBoolConsumerX<X>,X extends Throwable> LBoolConsumerXAssert.The<A,X>	assertThat(LBoolConsumerX<X> functionalInterface)
static <A extends LBoolFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBoolFunctionAssert.The<A,RS,R>	assertThat(LBoolFunction<R> functionalInterface)
static <A extends LBoolFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBoolFunctionXAssert.The<A,RS,R,X>	assertThat(LBoolFunctionX<R,X> functionalInterface)
static <A extends LBoolSupplier,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBoolSupplierAssert.The<A,RS>	assertThat(LBoolSupplier functionalInterface)
static <A extends LBoolSupplierX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBoolSupplierXAssert.The<A,RS,X>	assertThat(LBoolSupplierX<X> functionalInterface)
static <A extends LBoolToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LBoolToByteFunctionAssert.The<A,RS>	assertThat(LBoolToByteFunction functionalInterface)
static <A extends LBoolToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LBoolToByteFunctionXAssert.The<A,RS,X>	assertThat(LBoolToByteFunctionX<X> functionalInterface)
static <A extends LBoolToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LBoolToCharFunctionAssert.The<A,RS>	assertThat(LBoolToCharFunction functionalInterface)
static <A extends LBoolToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LBoolToCharFunctionXAssert.The<A,RS,X>	assertThat(LBoolToCharFunctionX<X> functionalInterface)
static <A extends LBoolToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LBoolToDoubleFunctionAssert.The<A,RS>	assertThat(LBoolToDoubleFunction functionalInterface)
static <A extends LBoolToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LBoolToDoubleFunctionXAssert.The<A,RS,X>	assertThat(LBoolToDoubleFunctionX<X> functionalInterface)
static <A extends LBoolToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LBoolToFloatFunctionAssert.The<A,RS>	assertThat(LBoolToFloatFunction functionalInterface)
static <A extends LBoolToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LBoolToFloatFunctionXAssert.The<A,RS,X>	assertThat(LBoolToFloatFunctionX<X> functionalInterface)
static <A extends LBoolToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LBoolToIntFunctionAssert.The<A,RS>	assertThat(LBoolToIntFunction functionalInterface)
static <A extends LBoolToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LBoolToIntFunctionXAssert.The<A,RS,X>	assertThat(LBoolToIntFunctionX<X> functionalInterface)
static <A extends LBoolToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LBoolToLongFunctionAssert.The<A,RS>	assertThat(LBoolToLongFunction functionalInterface)
static <A extends LBoolToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LBoolToLongFunctionXAssert.The<A,RS,X>	assertThat(LBoolToLongFunctionX<X> functionalInterface)
static <A extends LBoolToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LBoolToShortFunctionAssert.The<A,RS>	assertThat(LBoolToShortFunction functionalInterface)
static <A extends LBoolToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LBoolToShortFunctionXAssert.The<A,RS,X>	assertThat(LBoolToShortFunctionX<X> functionalInterface)
static <A extends LByteBinaryOperator,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LByteBinaryOperatorAssert.The<A,RS>	assertThat(LByteBinaryOperator functionalInterface)
static <A extends LByteBinaryOperatorX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LByteBinaryOperatorXAssert.The<A,RS,X>	assertThat(LByteBinaryOperatorX<X> functionalInterface)
static <A extends LByteConsumer> LByteConsumerAssert.The<A>	assertThat(LByteConsumer functionalInterface)
static <A extends LByteConsumerX<X>,X extends Throwable> LByteConsumerXAssert.The<A,X>	assertThat(LByteConsumerX<X> functionalInterface)
static <A extends LByteFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LByteFunctionAssert.The<A,RS,R>	assertThat(LByteFunction<R> functionalInterface)
static <A extends LByteFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LByteFunctionXAssert.The<A,RS,R,X>	assertThat(LByteFunctionX<R,X> functionalInterface)
static <A extends LBytePredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBytePredicateAssert.The<A,RS>	assertThat(LBytePredicate functionalInterface)
static <A extends LBytePredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBytePredicateXAssert.The<A,RS,X>	assertThat(LBytePredicateX<X> functionalInterface)
static <A extends LByteSupplier,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LByteSupplierAssert.The<A,RS>	assertThat(LByteSupplier functionalInterface)
static <A extends LByteSupplierX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LByteSupplierXAssert.The<A,RS,X>	assertThat(LByteSupplierX<X> functionalInterface)
static <A extends LByteToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LByteToCharFunctionAssert.The<A,RS>	assertThat(LByteToCharFunction functionalInterface)
static <A extends LByteToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LByteToCharFunctionXAssert.The<A,RS,X>	assertThat(LByteToCharFunctionX<X> functionalInterface)
static <A extends LByteToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LByteToDoubleFunctionAssert.The<A,RS>	assertThat(LByteToDoubleFunction functionalInterface)
static <A extends LByteToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LByteToDoubleFunctionXAssert.The<A,RS,X>	assertThat(LByteToDoubleFunctionX<X> functionalInterface)
static <A extends LByteToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LByteToFloatFunctionAssert.The<A,RS>	assertThat(LByteToFloatFunction functionalInterface)
static <A extends LByteToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LByteToFloatFunctionXAssert.The<A,RS,X>	assertThat(LByteToFloatFunctionX<X> functionalInterface)
static <A extends LByteToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LByteToIntFunctionAssert.The<A,RS>	assertThat(LByteToIntFunction functionalInterface)
static <A extends LByteToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LByteToIntFunctionXAssert.The<A,RS,X>	assertThat(LByteToIntFunctionX<X> functionalInterface)
static <A extends LByteToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LByteToLongFunctionAssert.The<A,RS>	assertThat(LByteToLongFunction functionalInterface)
static <A extends LByteToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LByteToLongFunctionXAssert.The<A,RS,X>	assertThat(LByteToLongFunctionX<X> functionalInterface)
static <A extends LByteToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LByteToShortFunctionAssert.The<A,RS>	assertThat(LByteToShortFunction functionalInterface)
static <A extends LByteToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LByteToShortFunctionXAssert.The<A,RS,X>	assertThat(LByteToShortFunctionX<X> functionalInterface)
static <A extends LByteUnaryOperator,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LByteUnaryOperatorAssert.The<A,RS>	assertThat(LByteUnaryOperator functionalInterface)
static <A extends LByteUnaryOperatorX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LByteUnaryOperatorXAssert.The<A,RS,X>	assertThat(LByteUnaryOperatorX<X> functionalInterface)
static <A extends LCharBinaryOperator,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LCharBinaryOperatorAssert.The<A,RS>	assertThat(LCharBinaryOperator functionalInterface)
static <A extends LCharBinaryOperatorX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LCharBinaryOperatorXAssert.The<A,RS,X>	assertThat(LCharBinaryOperatorX<X> functionalInterface)
static <A extends LCharConsumer> LCharConsumerAssert.The<A>	assertThat(LCharConsumer functionalInterface)
static <A extends LCharConsumerX<X>,X extends Throwable> LCharConsumerXAssert.The<A,X>	assertThat(LCharConsumerX<X> functionalInterface)
static <A extends LCharFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LCharFunctionAssert.The<A,RS,R>	assertThat(LCharFunction<R> functionalInterface)
static <A extends LCharFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LCharFunctionXAssert.The<A,RS,R,X>	assertThat(LCharFunctionX<R,X> functionalInterface)
static <A extends LCharPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LCharPredicateAssert.The<A,RS>	assertThat(LCharPredicate functionalInterface)
static <A extends LCharPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LCharPredicateXAssert.The<A,RS,X>	assertThat(LCharPredicateX<X> functionalInterface)
static <A extends LCharSupplier,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LCharSupplierAssert.The<A,RS>	assertThat(LCharSupplier functionalInterface)
static <A extends LCharSupplierX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LCharSupplierXAssert.The<A,RS,X>	assertThat(LCharSupplierX<X> functionalInterface)
static <A extends LCharToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LCharToByteFunctionAssert.The<A,RS>	assertThat(LCharToByteFunction functionalInterface)
static <A extends LCharToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LCharToByteFunctionXAssert.The<A,RS,X>	assertThat(LCharToByteFunctionX<X> functionalInterface)
static <A extends LCharToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LCharToDoubleFunctionAssert.The<A,RS>	assertThat(LCharToDoubleFunction functionalInterface)
static <A extends LCharToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LCharToDoubleFunctionXAssert.The<A,RS,X>	assertThat(LCharToDoubleFunctionX<X> functionalInterface)
static <A extends LCharToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LCharToFloatFunctionAssert.The<A,RS>	assertThat(LCharToFloatFunction functionalInterface)
static <A extends LCharToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LCharToFloatFunctionXAssert.The<A,RS,X>	assertThat(LCharToFloatFunctionX<X> functionalInterface)
static <A extends LCharToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LCharToIntFunctionAssert.The<A,RS>	assertThat(LCharToIntFunction functionalInterface)
static <A extends LCharToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LCharToIntFunctionXAssert.The<A,RS,X>	assertThat(LCharToIntFunctionX<X> functionalInterface)
static <A extends LCharToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LCharToLongFunctionAssert.The<A,RS>	assertThat(LCharToLongFunction functionalInterface)
static <A extends LCharToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LCharToLongFunctionXAssert.The<A,RS,X>	assertThat(LCharToLongFunctionX<X> functionalInterface)
static <A extends LCharToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LCharToShortFunctionAssert.The<A,RS>	assertThat(LCharToShortFunction functionalInterface)
static <A extends LCharToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LCharToShortFunctionXAssert.The<A,RS,X>	assertThat(LCharToShortFunctionX<X> functionalInterface)
static <A extends LCharUnaryOperator,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LCharUnaryOperatorAssert.The<A,RS>	assertThat(LCharUnaryOperator functionalInterface)
static <A extends LCharUnaryOperatorX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LCharUnaryOperatorXAssert.The<A,RS,X>	assertThat(LCharUnaryOperatorX<X> functionalInterface)
static <A extends LConsumer<T>,T> LConsumerAssert.The<A,T>	assertThat(LConsumer<T> functionalInterface)
static <A extends LConsumerX<T,X>,T,X extends Throwable> LConsumerXAssert.The<A,T,X>	assertThat(LConsumerX<T,X> functionalInterface)
static <A extends LDoubleBinaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LDoubleBinaryOperatorAssert.The<A,RS>	assertThat(LDoubleBinaryOperator functionalInterface)
static <A extends LDoubleBinaryOperatorX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LDoubleBinaryOperatorXAssert.The<A,RS,X>	assertThat(LDoubleBinaryOperatorX<X> functionalInterface)
static <A extends LDoubleConsumer> LDoubleConsumerAssert.The<A>	assertThat(LDoubleConsumer functionalInterface)
static <A extends LDoubleConsumerX<X>,X extends Throwable> LDoubleConsumerXAssert.The<A,X>	assertThat(LDoubleConsumerX<X> functionalInterface)
static <A extends LDoubleFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LDoubleFunctionAssert.The<A,RS,R>	assertThat(LDoubleFunction<R> functionalInterface)
static <A extends LDoubleFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LDoubleFunctionXAssert.The<A,RS,R,X>	assertThat(LDoubleFunctionX<R,X> functionalInterface)
static <A extends LDoublePredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LDoublePredicateAssert.The<A,RS>	assertThat(LDoublePredicate functionalInterface)
static <A extends LDoublePredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LDoublePredicateXAssert.The<A,RS,X>	assertThat(LDoublePredicateX<X> functionalInterface)
static <A extends LDoubleSupplier,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LDoubleSupplierAssert.The<A,RS>	assertThat(LDoubleSupplier functionalInterface)
static <A extends LDoubleSupplierX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LDoubleSupplierXAssert.The<A,RS,X>	assertThat(LDoubleSupplierX<X> functionalInterface)
static <A extends LDoubleToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LDoubleToByteFunctionAssert.The<A,RS>	assertThat(LDoubleToByteFunction functionalInterface)
static <A extends LDoubleToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LDoubleToByteFunctionXAssert.The<A,RS,X>	assertThat(LDoubleToByteFunctionX<X> functionalInterface)
static <A extends LDoubleToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LDoubleToCharFunctionAssert.The<A,RS>	assertThat(LDoubleToCharFunction functionalInterface)
static <A extends LDoubleToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LDoubleToCharFunctionXAssert.The<A,RS,X>	assertThat(LDoubleToCharFunctionX<X> functionalInterface)
static <A extends LDoubleToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LDoubleToFloatFunctionAssert.The<A,RS>	assertThat(LDoubleToFloatFunction functionalInterface)
static <A extends LDoubleToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LDoubleToFloatFunctionXAssert.The<A,RS,X>	assertThat(LDoubleToFloatFunctionX<X> functionalInterface)
static <A extends LDoubleToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LDoubleToIntFunctionAssert.The<A,RS>	assertThat(LDoubleToIntFunction functionalInterface)
static <A extends LDoubleToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LDoubleToIntFunctionXAssert.The<A,RS,X>	assertThat(LDoubleToIntFunctionX<X> functionalInterface)
static <A extends LDoubleToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LDoubleToLongFunctionAssert.The<A,RS>	assertThat(LDoubleToLongFunction functionalInterface)
static <A extends LDoubleToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LDoubleToLongFunctionXAssert.The<A,RS,X>	assertThat(LDoubleToLongFunctionX<X> functionalInterface)
static <A extends LDoubleToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LDoubleToShortFunctionAssert.The<A,RS>	assertThat(LDoubleToShortFunction functionalInterface)
static <A extends LDoubleToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LDoubleToShortFunctionXAssert.The<A,RS,X>	assertThat(LDoubleToShortFunctionX<X> functionalInterface)
static <A extends LDoubleUnaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LDoubleUnaryOperatorAssert.The<A,RS>	assertThat(LDoubleUnaryOperator functionalInterface)
static <A extends LDoubleUnaryOperatorX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LDoubleUnaryOperatorXAssert.The<A,RS,X>	assertThat(LDoubleUnaryOperatorX<X> functionalInterface)
static <A extends LFloatBinaryOperator,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LFloatBinaryOperatorAssert.The<A,RS>	assertThat(LFloatBinaryOperator functionalInterface)
static <A extends LFloatBinaryOperatorX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LFloatBinaryOperatorXAssert.The<A,RS,X>	assertThat(LFloatBinaryOperatorX<X> functionalInterface)
static <A extends LFloatConsumer> LFloatConsumerAssert.The<A>	assertThat(LFloatConsumer functionalInterface)
static <A extends LFloatConsumerX<X>,X extends Throwable> LFloatConsumerXAssert.The<A,X>	assertThat(LFloatConsumerX<X> functionalInterface)
static <A extends LFloatFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LFloatFunctionAssert.The<A,RS,R>	assertThat(LFloatFunction<R> functionalInterface)
static <A extends LFloatFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LFloatFunctionXAssert.The<A,RS,R,X>	assertThat(LFloatFunctionX<R,X> functionalInterface)
static <A extends LFloatPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LFloatPredicateAssert.The<A,RS>	assertThat(LFloatPredicate functionalInterface)
static <A extends LFloatPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LFloatPredicateXAssert.The<A,RS,X>	assertThat(LFloatPredicateX<X> functionalInterface)
static <A extends LFloatSupplier,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LFloatSupplierAssert.The<A,RS>	assertThat(LFloatSupplier functionalInterface)
static <A extends LFloatSupplierX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LFloatSupplierXAssert.The<A,RS,X>	assertThat(LFloatSupplierX<X> functionalInterface)
static <A extends LFloatToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LFloatToByteFunctionAssert.The<A,RS>	assertThat(LFloatToByteFunction functionalInterface)
static <A extends LFloatToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LFloatToByteFunctionXAssert.The<A,RS,X>	assertThat(LFloatToByteFunctionX<X> functionalInterface)
static <A extends LFloatToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LFloatToCharFunctionAssert.The<A,RS>	assertThat(LFloatToCharFunction functionalInterface)
static <A extends LFloatToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LFloatToCharFunctionXAssert.The<A,RS,X>	assertThat(LFloatToCharFunctionX<X> functionalInterface)
static <A extends LFloatToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LFloatToDoubleFunctionAssert.The<A,RS>	assertThat(LFloatToDoubleFunction functionalInterface)
static <A extends LFloatToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LFloatToDoubleFunctionXAssert.The<A,RS,X>	assertThat(LFloatToDoubleFunctionX<X> functionalInterface)
static <A extends LFloatToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LFloatToIntFunctionAssert.The<A,RS>	assertThat(LFloatToIntFunction functionalInterface)
static <A extends LFloatToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LFloatToIntFunctionXAssert.The<A,RS,X>	assertThat(LFloatToIntFunctionX<X> functionalInterface)
static <A extends LFloatToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LFloatToLongFunctionAssert.The<A,RS>	assertThat(LFloatToLongFunction functionalInterface)
static <A extends LFloatToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LFloatToLongFunctionXAssert.The<A,RS,X>	assertThat(LFloatToLongFunctionX<X> functionalInterface)
static <A extends LFloatToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LFloatToShortFunctionAssert.The<A,RS>	assertThat(LFloatToShortFunction functionalInterface)
static <A extends LFloatToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LFloatToShortFunctionXAssert.The<A,RS,X>	assertThat(LFloatToShortFunctionX<X> functionalInterface)
static <A extends LFloatUnaryOperator,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LFloatUnaryOperatorAssert.The<A,RS>	assertThat(LFloatUnaryOperator functionalInterface)
static <A extends LFloatUnaryOperatorX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LFloatUnaryOperatorXAssert.The<A,RS,X>	assertThat(LFloatUnaryOperatorX<X> functionalInterface)
static <A extends LFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LFunctionAssert.The<A,RS,T,R>	assertThat(LFunction<T,R> functionalInterface)
static <A extends LFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LFunctionXAssert.The<A,RS,T,R,X>	assertThat(LFunctionX<T,R,X> functionalInterface)
static <A extends LIntBinaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LIntBinaryOperatorAssert.The<A,RS>	assertThat(LIntBinaryOperator functionalInterface)
static <A extends LIntBinaryOperatorX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LIntBinaryOperatorXAssert.The<A,RS,X>	assertThat(LIntBinaryOperatorX<X> functionalInterface)
static <A extends LIntConsumer> LIntConsumerAssert.The<A>	assertThat(LIntConsumer functionalInterface)
static <A extends LIntConsumerX<X>,X extends Throwable> LIntConsumerXAssert.The<A,X>	assertThat(LIntConsumerX<X> functionalInterface)
static <A extends LIntFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LIntFunctionAssert.The<A,RS,R>	assertThat(LIntFunction<R> functionalInterface)
static <A extends LIntFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LIntFunctionXAssert.The<A,RS,R,X>	assertThat(LIntFunctionX<R,X> functionalInterface)
static <A extends LIntPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LIntPredicateAssert.The<A,RS>	assertThat(LIntPredicate functionalInterface)
static <A extends LIntPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LIntPredicateXAssert.The<A,RS,X>	assertThat(LIntPredicateX<X> functionalInterface)
static <A extends LIntSupplier,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LIntSupplierAssert.The<A,RS>	assertThat(LIntSupplier functionalInterface)
static <A extends LIntSupplierX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LIntSupplierXAssert.The<A,RS,X>	assertThat(LIntSupplierX<X> functionalInterface)
static <A extends LIntToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LIntToByteFunctionAssert.The<A,RS>	assertThat(LIntToByteFunction functionalInterface)
static <A extends LIntToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LIntToByteFunctionXAssert.The<A,RS,X>	assertThat(LIntToByteFunctionX<X> functionalInterface)
static <A extends LIntToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LIntToCharFunctionAssert.The<A,RS>	assertThat(LIntToCharFunction functionalInterface)
static <A extends LIntToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LIntToCharFunctionXAssert.The<A,RS,X>	assertThat(LIntToCharFunctionX<X> functionalInterface)
static <A extends LIntToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LIntToDoubleFunctionAssert.The<A,RS>	assertThat(LIntToDoubleFunction functionalInterface)
static <A extends LIntToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LIntToDoubleFunctionXAssert.The<A,RS,X>	assertThat(LIntToDoubleFunctionX<X> functionalInterface)
static <A extends LIntToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LIntToFloatFunctionAssert.The<A,RS>	assertThat(LIntToFloatFunction functionalInterface)
static <A extends LIntToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LIntToFloatFunctionXAssert.The<A,RS,X>	assertThat(LIntToFloatFunctionX<X> functionalInterface)
static <A extends LIntToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LIntToLongFunctionAssert.The<A,RS>	assertThat(LIntToLongFunction functionalInterface)
static <A extends LIntToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LIntToLongFunctionXAssert.The<A,RS,X>	assertThat(LIntToLongFunctionX<X> functionalInterface)
static <A extends LIntToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LIntToShortFunctionAssert.The<A,RS>	assertThat(LIntToShortFunction functionalInterface)
static <A extends LIntToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LIntToShortFunctionXAssert.The<A,RS,X>	assertThat(LIntToShortFunctionX<X> functionalInterface)
static <A extends LIntUnaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LIntUnaryOperatorAssert.The<A,RS>	assertThat(LIntUnaryOperator functionalInterface)
static <A extends LIntUnaryOperatorX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LIntUnaryOperatorXAssert.The<A,RS,X>	assertThat(LIntUnaryOperatorX<X> functionalInterface)
static <A extends LLogicalBinaryOperator,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LLogicalBinaryOperatorAssert.The<A,RS>	assertThat(LLogicalBinaryOperator functionalInterface)
static <A extends LLogicalBinaryOperatorX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LLogicalBinaryOperatorXAssert.The<A,RS,X>	assertThat(LLogicalBinaryOperatorX<X> functionalInterface)
static <A extends LLogicalOperator,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LLogicalOperatorAssert.The<A,RS>	assertThat(LLogicalOperator functionalInterface)
static <A extends LLogicalOperatorX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LLogicalOperatorXAssert.The<A,RS,X>	assertThat(LLogicalOperatorX<X> functionalInterface)
static <A extends LLogicalTernaryOperator,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LLogicalTernaryOperatorAssert.The<A,RS>	assertThat(LLogicalTernaryOperator functionalInterface)
static <A extends LLogicalTernaryOperatorX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LLogicalTernaryOperatorXAssert.The<A,RS,X>	assertThat(LLogicalTernaryOperatorX<X> functionalInterface)
static <A extends LLongBinaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LLongBinaryOperatorAssert.The<A,RS>	assertThat(LLongBinaryOperator functionalInterface)
static <A extends LLongBinaryOperatorX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LLongBinaryOperatorXAssert.The<A,RS,X>	assertThat(LLongBinaryOperatorX<X> functionalInterface)
static <A extends LLongConsumer> LLongConsumerAssert.The<A>	assertThat(LLongConsumer functionalInterface)
static <A extends LLongConsumerX<X>,X extends Throwable> LLongConsumerXAssert.The<A,X>	assertThat(LLongConsumerX<X> functionalInterface)
static <A extends LLongFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LLongFunctionAssert.The<A,RS,R>	assertThat(LLongFunction<R> functionalInterface)
static <A extends LLongFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LLongFunctionXAssert.The<A,RS,R,X>	assertThat(LLongFunctionX<R,X> functionalInterface)
static <A extends LLongPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LLongPredicateAssert.The<A,RS>	assertThat(LLongPredicate functionalInterface)
static <A extends LLongPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LLongPredicateXAssert.The<A,RS,X>	assertThat(LLongPredicateX<X> functionalInterface)
static <A extends LLongSupplier,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LLongSupplierAssert.The<A,RS>	assertThat(LLongSupplier functionalInterface)
static <A extends LLongSupplierX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LLongSupplierXAssert.The<A,RS,X>	assertThat(LLongSupplierX<X> functionalInterface)
static <A extends LLongToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LLongToByteFunctionAssert.The<A,RS>	assertThat(LLongToByteFunction functionalInterface)
static <A extends LLongToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LLongToByteFunctionXAssert.The<A,RS,X>	assertThat(LLongToByteFunctionX<X> functionalInterface)
static <A extends LLongToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LLongToCharFunctionAssert.The<A,RS>	assertThat(LLongToCharFunction functionalInterface)
static <A extends LLongToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LLongToCharFunctionXAssert.The<A,RS,X>	assertThat(LLongToCharFunctionX<X> functionalInterface)
static <A extends LLongToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LLongToDoubleFunctionAssert.The<A,RS>	assertThat(LLongToDoubleFunction functionalInterface)
static <A extends LLongToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LLongToDoubleFunctionXAssert.The<A,RS,X>	assertThat(LLongToDoubleFunctionX<X> functionalInterface)
static <A extends LLongToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LLongToFloatFunctionAssert.The<A,RS>	assertThat(LLongToFloatFunction functionalInterface)
static <A extends LLongToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LLongToFloatFunctionXAssert.The<A,RS,X>	assertThat(LLongToFloatFunctionX<X> functionalInterface)
static <A extends LLongToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LLongToIntFunctionAssert.The<A,RS>	assertThat(LLongToIntFunction functionalInterface)
static <A extends LLongToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LLongToIntFunctionXAssert.The<A,RS,X>	assertThat(LLongToIntFunctionX<X> functionalInterface)
static <A extends LLongToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LLongToShortFunctionAssert.The<A,RS>	assertThat(LLongToShortFunction functionalInterface)
static <A extends LLongToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LLongToShortFunctionXAssert.The<A,RS,X>	assertThat(LLongToShortFunctionX<X> functionalInterface)
static <A extends LLongUnaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LLongUnaryOperatorAssert.The<A,RS>	assertThat(LLongUnaryOperator functionalInterface)
static <A extends LLongUnaryOperatorX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LLongUnaryOperatorXAssert.The<A,RS,X>	assertThat(LLongUnaryOperatorX<X> functionalInterface)
static <A extends LObjBoolConsumer<T>,T> LObjBoolConsumerAssert.The<A,T>	assertThat(LObjBoolConsumer<T> functionalInterface)
static <A extends LObjBoolConsumerX<T,X>,T,X extends Throwable> LObjBoolConsumerXAssert.The<A,T,X>	assertThat(LObjBoolConsumerX<T,X> functionalInterface)
static <A extends LObjBoolFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LObjBoolFunctionAssert.The<A,RS,T,R>	assertThat(LObjBoolFunction<T,R> functionalInterface)
static <A extends LObjBoolFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LObjBoolFunctionXAssert.The<A,RS,T,R,X>	assertThat(LObjBoolFunctionX<T,R,X> functionalInterface)
static <A extends LObjBoolPredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LObjBoolPredicateAssert.The<A,RS,T>	assertThat(LObjBoolPredicate<T> functionalInterface)
static <A extends LObjBoolPredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LObjBoolPredicateXAssert.The<A,RS,T,X>	assertThat(LObjBoolPredicateX<T,X> functionalInterface)
static <A extends LObjByteConsumer<T>,T> LObjByteConsumerAssert.The<A,T>	assertThat(LObjByteConsumer<T> functionalInterface)
static <A extends LObjByteConsumerX<T,X>,T,X extends Throwable> LObjByteConsumerXAssert.The<A,T,X>	assertThat(LObjByteConsumerX<T,X> functionalInterface)
static <A extends LObjByteFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LObjByteFunctionAssert.The<A,RS,T,R>	assertThat(LObjByteFunction<T,R> functionalInterface)
static <A extends LObjByteFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LObjByteFunctionXAssert.The<A,RS,T,R,X>	assertThat(LObjByteFunctionX<T,R,X> functionalInterface)
static <A extends LObjBytePredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LObjBytePredicateAssert.The<A,RS,T>	assertThat(LObjBytePredicate<T> functionalInterface)
static <A extends LObjBytePredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LObjBytePredicateXAssert.The<A,RS,T,X>	assertThat(LObjBytePredicateX<T,X> functionalInterface)
static <A extends LObjCharConsumer<T>,T> LObjCharConsumerAssert.The<A,T>	assertThat(LObjCharConsumer<T> functionalInterface)
static <A extends LObjCharConsumerX<T,X>,T,X extends Throwable> LObjCharConsumerXAssert.The<A,T,X>	assertThat(LObjCharConsumerX<T,X> functionalInterface)
static <A extends LObjCharFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LObjCharFunctionAssert.The<A,RS,T,R>	assertThat(LObjCharFunction<T,R> functionalInterface)
static <A extends LObjCharFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LObjCharFunctionXAssert.The<A,RS,T,R,X>	assertThat(LObjCharFunctionX<T,R,X> functionalInterface)
static <A extends LObjCharPredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LObjCharPredicateAssert.The<A,RS,T>	assertThat(LObjCharPredicate<T> functionalInterface)
static <A extends LObjCharPredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LObjCharPredicateXAssert.The<A,RS,T,X>	assertThat(LObjCharPredicateX<T,X> functionalInterface)
static <A extends LObjDoubleConsumer<T>,T> LObjDoubleConsumerAssert.The<A,T>	assertThat(LObjDoubleConsumer<T> functionalInterface)
static <A extends LObjDoubleConsumerX<T,X>,T,X extends Throwable> LObjDoubleConsumerXAssert.The<A,T,X>	assertThat(LObjDoubleConsumerX<T,X> functionalInterface)
static <A extends LObjDoubleFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LObjDoubleFunctionAssert.The<A,RS,T,R>	assertThat(LObjDoubleFunction<T,R> functionalInterface)
static <A extends LObjDoubleFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LObjDoubleFunctionXAssert.The<A,RS,T,R,X>	assertThat(LObjDoubleFunctionX<T,R,X> functionalInterface)
static <A extends LObjDoublePredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LObjDoublePredicateAssert.The<A,RS,T>	assertThat(LObjDoublePredicate<T> functionalInterface)
static <A extends LObjDoublePredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LObjDoublePredicateXAssert.The<A,RS,T,X>	assertThat(LObjDoublePredicateX<T,X> functionalInterface)
static <A extends LObjFloatConsumer<T>,T> LObjFloatConsumerAssert.The<A,T>	assertThat(LObjFloatConsumer<T> functionalInterface)
static <A extends LObjFloatConsumerX<T,X>,T,X extends Throwable> LObjFloatConsumerXAssert.The<A,T,X>	assertThat(LObjFloatConsumerX<T,X> functionalInterface)
static <A extends LObjFloatFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LObjFloatFunctionAssert.The<A,RS,T,R>	assertThat(LObjFloatFunction<T,R> functionalInterface)
static <A extends LObjFloatFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LObjFloatFunctionXAssert.The<A,RS,T,R,X>	assertThat(LObjFloatFunctionX<T,R,X> functionalInterface)
static <A extends LObjFloatPredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LObjFloatPredicateAssert.The<A,RS,T>	assertThat(LObjFloatPredicate<T> functionalInterface)
static <A extends LObjFloatPredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LObjFloatPredicateXAssert.The<A,RS,T,X>	assertThat(LObjFloatPredicateX<T,X> functionalInterface)
static <A extends LObjIntConsumer<T>,T> LObjIntConsumerAssert.The<A,T>	assertThat(LObjIntConsumer<T> functionalInterface)
static <A extends LObjIntConsumerX<T,X>,T,X extends Throwable> LObjIntConsumerXAssert.The<A,T,X>	assertThat(LObjIntConsumerX<T,X> functionalInterface)
static <A extends LObjIntFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LObjIntFunctionAssert.The<A,RS,T,R>	assertThat(LObjIntFunction<T,R> functionalInterface)
static <A extends LObjIntFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LObjIntFunctionXAssert.The<A,RS,T,R,X>	assertThat(LObjIntFunctionX<T,R,X> functionalInterface)
static <A extends LObjIntPredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LObjIntPredicateAssert.The<A,RS,T>	assertThat(LObjIntPredicate<T> functionalInterface)
static <A extends LObjIntPredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LObjIntPredicateXAssert.The<A,RS,T,X>	assertThat(LObjIntPredicateX<T,X> functionalInterface)
static <A extends LObjIntToIntFunction<T>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T> LObjIntToIntFunctionAssert.The<A,RS,T>	assertThat(LObjIntToIntFunction<T> functionalInterface)
static <A extends LObjIntToIntFunctionX<T,X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T,X extends Throwable> LObjIntToIntFunctionXAssert.The<A,RS,T,X>	assertThat(LObjIntToIntFunctionX<T,X> functionalInterface)
static <A extends LObjLongConsumer<T>,T> LObjLongConsumerAssert.The<A,T>	assertThat(LObjLongConsumer<T> functionalInterface)
static <A extends LObjLongConsumerX<T,X>,T,X extends Throwable> LObjLongConsumerXAssert.The<A,T,X>	assertThat(LObjLongConsumerX<T,X> functionalInterface)
static <A extends LObjLongFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LObjLongFunctionAssert.The<A,RS,T,R>	assertThat(LObjLongFunction<T,R> functionalInterface)
static <A extends LObjLongFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LObjLongFunctionXAssert.The<A,RS,T,R,X>	assertThat(LObjLongFunctionX<T,R,X> functionalInterface)
static <A extends LObjLongPredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LObjLongPredicateAssert.The<A,RS,T>	assertThat(LObjLongPredicate<T> functionalInterface)
static <A extends LObjLongPredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LObjLongPredicateXAssert.The<A,RS,T,X>	assertThat(LObjLongPredicateX<T,X> functionalInterface)
static <A extends LObjShortConsumer<T>,T> LObjShortConsumerAssert.The<A,T>	assertThat(LObjShortConsumer<T> functionalInterface)
static <A extends LObjShortConsumerX<T,X>,T,X extends Throwable> LObjShortConsumerXAssert.The<A,T,X>	assertThat(LObjShortConsumerX<T,X> functionalInterface)
static <A extends LObjShortFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LObjShortFunctionAssert.The<A,RS,T,R>	assertThat(LObjShortFunction<T,R> functionalInterface)
static <A extends LObjShortFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LObjShortFunctionXAssert.The<A,RS,T,R,X>	assertThat(LObjShortFunctionX<T,R,X> functionalInterface)
static <A extends LObjShortPredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LObjShortPredicateAssert.The<A,RS,T>	assertThat(LObjShortPredicate<T> functionalInterface)
static <A extends LObjShortPredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LObjShortPredicateXAssert.The<A,RS,T,X>	assertThat(LObjShortPredicateX<T,X> functionalInterface)
static <A extends java.util.function.LongBinaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LongBinaryOperatorAssert.The<A,RS>	assertThat(java.util.function.LongBinaryOperator functionalInterface)
static <A extends java.util.function.LongConsumer> LongConsumerAssert.The<A>	assertThat(java.util.function.LongConsumer functionalInterface)
static <A extends java.util.function.LongFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LongFunctionAssert.The<A,RS,R>	assertThat(java.util.function.LongFunction<R> functionalInterface)
static <A extends java.util.function.LongPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LongPredicateAssert.The<A,RS>	assertThat(java.util.function.LongPredicate functionalInterface)
static <A extends java.util.function.LongSupplier,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LongSupplierAssert.The<A,RS>	assertThat(java.util.function.LongSupplier functionalInterface)
static <A extends java.util.function.LongToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LongToDoubleFunctionAssert.The<A,RS>	assertThat(java.util.function.LongToDoubleFunction functionalInterface)
static <A extends java.util.function.LongToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LongToIntFunctionAssert.The<A,RS>	assertThat(java.util.function.LongToIntFunction functionalInterface)
static <A extends java.util.function.LongUnaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LongUnaryOperatorAssert.The<A,RS>	assertThat(java.util.function.LongUnaryOperator functionalInterface)
static <A extends LPredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LPredicateAssert.The<A,RS,T>	assertThat(LPredicate<T> functionalInterface)
static <A extends LPredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LPredicateXAssert.The<A,RS,T,X>	assertThat(LPredicateX<T,X> functionalInterface)
static <A extends LShortBinaryOperator,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LShortBinaryOperatorAssert.The<A,RS>	assertThat(LShortBinaryOperator functionalInterface)
static <A extends LShortBinaryOperatorX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LShortBinaryOperatorXAssert.The<A,RS,X>	assertThat(LShortBinaryOperatorX<X> functionalInterface)
static <A extends LShortConsumer> LShortConsumerAssert.The<A>	assertThat(LShortConsumer functionalInterface)
static <A extends LShortConsumerX<X>,X extends Throwable> LShortConsumerXAssert.The<A,X>	assertThat(LShortConsumerX<X> functionalInterface)
static <A extends LShortFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LShortFunctionAssert.The<A,RS,R>	assertThat(LShortFunction<R> functionalInterface)
static <A extends LShortFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LShortFunctionXAssert.The<A,RS,R,X>	assertThat(LShortFunctionX<R,X> functionalInterface)
static <A extends LShortPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LShortPredicateAssert.The<A,RS>	assertThat(LShortPredicate functionalInterface)
static <A extends LShortPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LShortPredicateXAssert.The<A,RS,X>	assertThat(LShortPredicateX<X> functionalInterface)
static <A extends LShortSupplier,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LShortSupplierAssert.The<A,RS>	assertThat(LShortSupplier functionalInterface)
static <A extends LShortSupplierX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LShortSupplierXAssert.The<A,RS,X>	assertThat(LShortSupplierX<X> functionalInterface)
static <A extends LShortToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LShortToByteFunctionAssert.The<A,RS>	assertThat(LShortToByteFunction functionalInterface)
static <A extends LShortToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LShortToByteFunctionXAssert.The<A,RS,X>	assertThat(LShortToByteFunctionX<X> functionalInterface)
static <A extends LShortToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LShortToCharFunctionAssert.The<A,RS>	assertThat(LShortToCharFunction functionalInterface)
static <A extends LShortToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LShortToCharFunctionXAssert.The<A,RS,X>	assertThat(LShortToCharFunctionX<X> functionalInterface)
static <A extends LShortToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LShortToDoubleFunctionAssert.The<A,RS>	assertThat(LShortToDoubleFunction functionalInterface)
static <A extends LShortToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LShortToDoubleFunctionXAssert.The<A,RS,X>	assertThat(LShortToDoubleFunctionX<X> functionalInterface)
static <A extends LShortToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LShortToFloatFunctionAssert.The<A,RS>	assertThat(LShortToFloatFunction functionalInterface)
static <A extends LShortToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LShortToFloatFunctionXAssert.The<A,RS,X>	assertThat(LShortToFloatFunctionX<X> functionalInterface)
static <A extends LShortToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LShortToIntFunctionAssert.The<A,RS>	assertThat(LShortToIntFunction functionalInterface)
static <A extends LShortToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LShortToIntFunctionXAssert.The<A,RS,X>	assertThat(LShortToIntFunctionX<X> functionalInterface)
static <A extends LShortToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LShortToLongFunctionAssert.The<A,RS>	assertThat(LShortToLongFunction functionalInterface)
static <A extends LShortToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LShortToLongFunctionXAssert.The<A,RS,X>	assertThat(LShortToLongFunctionX<X> functionalInterface)
static <A extends LShortUnaryOperator,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LShortUnaryOperatorAssert.The<A,RS>	assertThat(LShortUnaryOperator functionalInterface)
static <A extends LShortUnaryOperatorX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LShortUnaryOperatorXAssert.The<A,RS,X>	assertThat(LShortUnaryOperatorX<X> functionalInterface)
static <A extends LSupplier<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LSupplierAssert.The<A,RS,R>	assertThat(LSupplier<R> functionalInterface)
static <A extends LSupplierX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LSupplierXAssert.The<A,RS,R,X>	assertThat(LSupplierX<R,X> functionalInterface)
static <A extends LTernaryOperator<T>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,T>,T> LTernaryOperatorAssert.The<A,RS,T>	assertThat(LTernaryOperator<T> functionalInterface)
static <A extends LTernaryOperatorX<T,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,T>,T,X extends Throwable> LTernaryOperatorXAssert.The<A,RS,T,X>	assertThat(LTernaryOperatorX<T,X> functionalInterface)
static <A extends LToByteBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,T1,T2> LToByteBiFunctionAssert.The<A,RS,T1,T2>	assertThat(LToByteBiFunction<T1,T2> functionalInterface)
static <A extends LToByteBiFunctionX<T1,T2,X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,T1,T2,X extends Throwable> LToByteBiFunctionXAssert.The<A,RS,T1,T2,X>	assertThat(LToByteBiFunctionX<T1,T2,X> functionalInterface)
static <A extends LToByteFunction<T>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,T> LToByteFunctionAssert.The<A,RS,T>	assertThat(LToByteFunction<T> functionalInterface)
static <A extends LToByteFunctionX<T,X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,T,X extends Throwable> LToByteFunctionXAssert.The<A,RS,T,X>	assertThat(LToByteFunctionX<T,X> functionalInterface)
static <A extends LToCharBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,T1,T2> LToCharBiFunctionAssert.The<A,RS,T1,T2>	assertThat(LToCharBiFunction<T1,T2> functionalInterface)
static <A extends LToCharBiFunctionX<T1,T2,X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,T1,T2,X extends Throwable> LToCharBiFunctionXAssert.The<A,RS,T1,T2,X>	assertThat(LToCharBiFunctionX<T1,T2,X> functionalInterface)
static <A extends LToCharFunction<T>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,T> LToCharFunctionAssert.The<A,RS,T>	assertThat(LToCharFunction<T> functionalInterface)
static <A extends LToCharFunctionX<T,X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,T,X extends Throwable> LToCharFunctionXAssert.The<A,RS,T,X>	assertThat(LToCharFunctionX<T,X> functionalInterface)
static <A extends LToDoubleBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T1,T2> LToDoubleBiFunctionAssert.The<A,RS,T1,T2>	assertThat(LToDoubleBiFunction<T1,T2> functionalInterface)
static <A extends LToDoubleBiFunctionX<T1,T2,X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T1,T2,X extends Throwable> LToDoubleBiFunctionXAssert.The<A,RS,T1,T2,X>	assertThat(LToDoubleBiFunctionX<T1,T2,X> functionalInterface)
static <A extends LToDoubleFunction<T>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T> LToDoubleFunctionAssert.The<A,RS,T>	assertThat(LToDoubleFunction<T> functionalInterface)
static <A extends LToDoubleFunctionX<T,X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T,X extends Throwable> LToDoubleFunctionXAssert.The<A,RS,T,X>	assertThat(LToDoubleFunctionX<T,X> functionalInterface)
static <A extends LToFloatBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,T1,T2> LToFloatBiFunctionAssert.The<A,RS,T1,T2>	assertThat(LToFloatBiFunction<T1,T2> functionalInterface)
static <A extends LToFloatBiFunctionX<T1,T2,X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,T1,T2,X extends Throwable> LToFloatBiFunctionXAssert.The<A,RS,T1,T2,X>	assertThat(LToFloatBiFunctionX<T1,T2,X> functionalInterface)
static <A extends LToFloatFunction<T>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,T> LToFloatFunctionAssert.The<A,RS,T>	assertThat(LToFloatFunction<T> functionalInterface)
static <A extends LToFloatFunctionX<T,X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,T,X extends Throwable> LToFloatFunctionXAssert.The<A,RS,T,X>	assertThat(LToFloatFunctionX<T,X> functionalInterface)
static <A extends LToIntBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T1,T2> LToIntBiFunctionAssert.The<A,RS,T1,T2>	assertThat(LToIntBiFunction<T1,T2> functionalInterface)
static <A extends LToIntBiFunctionX<T1,T2,X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T1,T2,X extends Throwable> LToIntBiFunctionXAssert.The<A,RS,T1,T2,X>	assertThat(LToIntBiFunctionX<T1,T2,X> functionalInterface)
static <A extends LToIntFunction<T>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T> LToIntFunctionAssert.The<A,RS,T>	assertThat(LToIntFunction<T> functionalInterface)
static <A extends LToIntFunctionX<T,X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T,X extends Throwable> LToIntFunctionXAssert.The<A,RS,T,X>	assertThat(LToIntFunctionX<T,X> functionalInterface)
static <A extends LToLongBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T1,T2> LToLongBiFunctionAssert.The<A,RS,T1,T2>	assertThat(LToLongBiFunction<T1,T2> functionalInterface)
static <A extends LToLongBiFunctionX<T1,T2,X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T1,T2,X extends Throwable> LToLongBiFunctionXAssert.The<A,RS,T1,T2,X>	assertThat(LToLongBiFunctionX<T1,T2,X> functionalInterface)
static <A extends LToLongFunction<T>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T> LToLongFunctionAssert.The<A,RS,T>	assertThat(LToLongFunction<T> functionalInterface)
static <A extends LToLongFunctionX<T,X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T,X extends Throwable> LToLongFunctionXAssert.The<A,RS,T,X>	assertThat(LToLongFunctionX<T,X> functionalInterface)
static <A extends LToShortBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,T1,T2> LToShortBiFunctionAssert.The<A,RS,T1,T2>	assertThat(LToShortBiFunction<T1,T2> functionalInterface)
static <A extends LToShortBiFunctionX<T1,T2,X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,T1,T2,X extends Throwable> LToShortBiFunctionXAssert.The<A,RS,T1,T2,X>	assertThat(LToShortBiFunctionX<T1,T2,X> functionalInterface)
static <A extends LToShortFunction<T>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,T> LToShortFunctionAssert.The<A,RS,T>	assertThat(LToShortFunction<T> functionalInterface)
static <A extends LToShortFunctionX<T,X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,T,X extends Throwable> LToShortFunctionXAssert.The<A,RS,T,X>	assertThat(LToShortFunctionX<T,X> functionalInterface)
static <A extends LTriBoolConsumer> LTriBoolConsumerAssert.The<A>	assertThat(LTriBoolConsumer functionalInterface)
static <A extends LTriBoolConsumerX<X>,X extends Throwable> LTriBoolConsumerXAssert.The<A,X>	assertThat(LTriBoolConsumerX<X> functionalInterface)
static <A extends LTriBoolFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LTriBoolFunctionAssert.The<A,RS,R>	assertThat(LTriBoolFunction<R> functionalInterface)
static <A extends LTriBoolFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LTriBoolFunctionXAssert.The<A,RS,R,X>	assertThat(LTriBoolFunctionX<R,X> functionalInterface)
static <A extends LTriConsumer<T1,T2,T3>,T1,T2,T3> LTriConsumerAssert.The<A,T1,T2,T3>	assertThat(LTriConsumer<T1,T2,T3> functionalInterface)
static <A extends LTriConsumerX<T1,T2,T3,X>,T1,T2,T3,X extends Throwable> LTriConsumerXAssert.The<A,T1,T2,T3,X>	assertThat(LTriConsumerX<T1,T2,T3,X> functionalInterface)
static <A extends LTriFunction<T1,T2,T3,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,T3,R> LTriFunctionAssert.The<A,RS,T1,T2,T3,R>	assertThat(LTriFunction<T1,T2,T3,R> functionalInterface)
static <A extends LTriFunctionX<T1,T2,T3,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,T3,R,X extends Throwable> LTriFunctionXAssert.The<A,RS,T1,T2,T3,R,X>	assertThat(LTriFunctionX<T1,T2,T3,R,X> functionalInterface)
static <A extends LTriPredicate<T1,T2,T3>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,T3> LTriPredicateAssert.The<A,RS,T1,T2,T3>	assertThat(LTriPredicate<T1,T2,T3> functionalInterface)
static <A extends LTriPredicateX<T1,T2,T3,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,T3,X extends Throwable> LTriPredicateXAssert.The<A,RS,T1,T2,T3,X>	assertThat(LTriPredicateX<T1,T2,T3,X> functionalInterface)
static <A extends LUnaryOperator<T>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,T>,T> LUnaryOperatorAssert.The<A,RS,T>	assertThat(LUnaryOperator<T> functionalInterface)
static <A extends LUnaryOperatorX<T,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,T>,T,X extends Throwable> LUnaryOperatorXAssert.The<A,RS,T,X>	assertThat(LUnaryOperatorX<T,X> functionalInterface)
static <A extends java.util.function.ObjDoubleConsumer<T>,T> ObjDoubleConsumerAssert.The<A,T>	assertThat(java.util.function.ObjDoubleConsumer<T> functionalInterface)
static <A extends java.util.function.ObjIntConsumer<T>,T> ObjIntConsumerAssert.The<A,T>	assertThat(java.util.function.ObjIntConsumer<T> functionalInterface)
static <A extends java.util.function.ObjLongConsumer<T>,T> ObjLongConsumerAssert.The<A,T>	assertThat(java.util.function.ObjLongConsumer<T> functionalInterface)
static <A extends java.util.function.Predicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> PredicateAssert.The<A,RS,T>	assertThat(java.util.function.Predicate<T> functionalInterface)
static <A extends java.util.function.Supplier<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> SupplierAssert.The<A,RS,R>	assertThat(java.util.function.Supplier<R> functionalInterface)
static <A extends java.util.function.ToDoubleBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T1,T2> ToDoubleBiFunctionAssert.The<A,RS,T1,T2>	assertThat(java.util.function.ToDoubleBiFunction<T1,T2> functionalInterface)
static <A extends java.util.function.ToDoubleFunction<T>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T> ToDoubleFunctionAssert.The<A,RS,T>	assertThat(java.util.function.ToDoubleFunction<T> functionalInterface)
static <A extends java.util.function.ToIntBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T1,T2> ToIntBiFunctionAssert.The<A,RS,T1,T2>	assertThat(java.util.function.ToIntBiFunction<T1,T2> functionalInterface)
static <A extends java.util.function.ToIntFunction<T>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T> ToIntFunctionAssert.The<A,RS,T>	assertThat(java.util.function.ToIntFunction<T> functionalInterface)
static <A extends java.util.function.ToLongBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T1,T2> ToLongBiFunctionAssert.The<A,RS,T1,T2>	assertThat(java.util.function.ToLongBiFunction<T1,T2> functionalInterface)
static <A extends java.util.function.ToLongFunction<T>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T> ToLongFunctionAssert.The<A,RS,T>	assertThat(java.util.function.ToLongFunction<T> functionalInterface)
static <A extends java.util.function.UnaryOperator<T>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,T>,T> UnaryOperatorAssert.The<A,RS,T>	assertThat(java.util.function.UnaryOperator<T> functionalInterface)

Method Detail

assertThat

@Nonnull
static <A extends LAction> LActionAssert.The<A> assertThat(LAction functionalInterface)

assertThat

@Nonnull
static <A extends LActionX<X>,X extends Throwable> LActionXAssert.The<A,X> assertThat(LActionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LConsumer<T>,T> LConsumerAssert.The<A,T> assertThat(LConsumer<T> functionalInterface)

assertThat

@Nonnull
static <A extends LConsumerX<T,X>,T,X extends Throwable> LConsumerXAssert.The<A,T,X> assertThat(LConsumerX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiConsumer<T1,T2>,T1,T2> LBiConsumerAssert.The<A,T1,T2> assertThat(LBiConsumer<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiConsumerXAssert.The<A,T1,T2,X> assertThat(LBiConsumerX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LTriConsumer<T1,T2,T3>,T1,T2,T3> LTriConsumerAssert.The<A,T1,T2,T3> assertThat(LTriConsumer<T1,T2,T3> functionalInterface)

assertThat

@Nonnull
static <A extends LTriConsumerX<T1,T2,T3,X>,T1,T2,T3,X extends Throwable> LTriConsumerXAssert.The<A,T1,T2,T3,X> assertThat(LTriConsumerX<T1,T2,T3,X> functionalInterface)

assertThat

@Nonnull
static <A extends LByteConsumer> LByteConsumerAssert.The<A> assertThat(LByteConsumer functionalInterface)

assertThat

@Nonnull
static <A extends LByteConsumerX<X>,X extends Throwable> LByteConsumerXAssert.The<A,X> assertThat(LByteConsumerX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LShortConsumer> LShortConsumerAssert.The<A> assertThat(LShortConsumer functionalInterface)

assertThat

@Nonnull
static <A extends LShortConsumerX<X>,X extends Throwable> LShortConsumerXAssert.The<A,X> assertThat(LShortConsumerX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LIntConsumer> LIntConsumerAssert.The<A> assertThat(LIntConsumer functionalInterface)

assertThat

@Nonnull
static <A extends LIntConsumerX<X>,X extends Throwable> LIntConsumerXAssert.The<A,X> assertThat(LIntConsumerX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LLongConsumer> LLongConsumerAssert.The<A> assertThat(LLongConsumer functionalInterface)

assertThat

@Nonnull
static <A extends LLongConsumerX<X>,X extends Throwable> LLongConsumerXAssert.The<A,X> assertThat(LLongConsumerX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LFloatConsumer> LFloatConsumerAssert.The<A> assertThat(LFloatConsumer functionalInterface)

assertThat

@Nonnull
static <A extends LFloatConsumerX<X>,X extends Throwable> LFloatConsumerXAssert.The<A,X> assertThat(LFloatConsumerX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleConsumer> LDoubleConsumerAssert.The<A> assertThat(LDoubleConsumer functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleConsumerX<X>,X extends Throwable> LDoubleConsumerXAssert.The<A,X> assertThat(LDoubleConsumerX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LCharConsumer> LCharConsumerAssert.The<A> assertThat(LCharConsumer functionalInterface)

assertThat

@Nonnull
static <A extends LCharConsumerX<X>,X extends Throwable> LCharConsumerXAssert.The<A,X> assertThat(LCharConsumerX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBoolConsumer> LBoolConsumerAssert.The<A> assertThat(LBoolConsumer functionalInterface)

assertThat

@Nonnull
static <A extends LBoolConsumerX<X>,X extends Throwable> LBoolConsumerXAssert.The<A,X> assertThat(LBoolConsumerX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiByteConsumer> LBiByteConsumerAssert.The<A> assertThat(LBiByteConsumer functionalInterface)

assertThat

@Nonnull
static <A extends LBiByteConsumerX<X>,X extends Throwable> LBiByteConsumerXAssert.The<A,X> assertThat(LBiByteConsumerX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiShortConsumer> LBiShortConsumerAssert.The<A> assertThat(LBiShortConsumer functionalInterface)

assertThat

@Nonnull
static <A extends LBiShortConsumerX<X>,X extends Throwable> LBiShortConsumerXAssert.The<A,X> assertThat(LBiShortConsumerX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiIntConsumer> LBiIntConsumerAssert.The<A> assertThat(LBiIntConsumer functionalInterface)

assertThat

@Nonnull
static <A extends LBiIntConsumerX<X>,X extends Throwable> LBiIntConsumerXAssert.The<A,X> assertThat(LBiIntConsumerX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiLongConsumer> LBiLongConsumerAssert.The<A> assertThat(LBiLongConsumer functionalInterface)

assertThat

@Nonnull
static <A extends LBiLongConsumerX<X>,X extends Throwable> LBiLongConsumerXAssert.The<A,X> assertThat(LBiLongConsumerX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiFloatConsumer> LBiFloatConsumerAssert.The<A> assertThat(LBiFloatConsumer functionalInterface)

assertThat

@Nonnull
static <A extends LBiFloatConsumerX<X>,X extends Throwable> LBiFloatConsumerXAssert.The<A,X> assertThat(LBiFloatConsumerX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiDoubleConsumer> LBiDoubleConsumerAssert.The<A> assertThat(LBiDoubleConsumer functionalInterface)

assertThat

@Nonnull
static <A extends LBiDoubleConsumerX<X>,X extends Throwable> LBiDoubleConsumerXAssert.The<A,X> assertThat(LBiDoubleConsumerX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiCharConsumer> LBiCharConsumerAssert.The<A> assertThat(LBiCharConsumer functionalInterface)

assertThat

@Nonnull
static <A extends LBiCharConsumerX<X>,X extends Throwable> LBiCharConsumerXAssert.The<A,X> assertThat(LBiCharConsumerX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiBoolConsumer> LBiBoolConsumerAssert.The<A> assertThat(LBiBoolConsumer functionalInterface)

assertThat

@Nonnull
static <A extends LBiBoolConsumerX<X>,X extends Throwable> LBiBoolConsumerXAssert.The<A,X> assertThat(LBiBoolConsumerX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LTriBoolConsumer> LTriBoolConsumerAssert.The<A> assertThat(LTriBoolConsumer functionalInterface)

assertThat

@Nonnull
static <A extends LTriBoolConsumerX<X>,X extends Throwable> LTriBoolConsumerXAssert.The<A,X> assertThat(LTriBoolConsumerX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjByteConsumer<T>,T> LObjByteConsumerAssert.The<A,T> assertThat(LObjByteConsumer<T> functionalInterface)

assertThat

@Nonnull
static <A extends LObjByteConsumerX<T,X>,T,X extends Throwable> LObjByteConsumerXAssert.The<A,T,X> assertThat(LObjByteConsumerX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjShortConsumer<T>,T> LObjShortConsumerAssert.The<A,T> assertThat(LObjShortConsumer<T> functionalInterface)

assertThat

@Nonnull
static <A extends LObjShortConsumerX<T,X>,T,X extends Throwable> LObjShortConsumerXAssert.The<A,T,X> assertThat(LObjShortConsumerX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjIntConsumer<T>,T> LObjIntConsumerAssert.The<A,T> assertThat(LObjIntConsumer<T> functionalInterface)

assertThat

@Nonnull
static <A extends LObjIntConsumerX<T,X>,T,X extends Throwable> LObjIntConsumerXAssert.The<A,T,X> assertThat(LObjIntConsumerX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjLongConsumer<T>,T> LObjLongConsumerAssert.The<A,T> assertThat(LObjLongConsumer<T> functionalInterface)

assertThat

@Nonnull
static <A extends LObjLongConsumerX<T,X>,T,X extends Throwable> LObjLongConsumerXAssert.The<A,T,X> assertThat(LObjLongConsumerX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjFloatConsumer<T>,T> LObjFloatConsumerAssert.The<A,T> assertThat(LObjFloatConsumer<T> functionalInterface)

assertThat

@Nonnull
static <A extends LObjFloatConsumerX<T,X>,T,X extends Throwable> LObjFloatConsumerXAssert.The<A,T,X> assertThat(LObjFloatConsumerX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjDoubleConsumer<T>,T> LObjDoubleConsumerAssert.The<A,T> assertThat(LObjDoubleConsumer<T> functionalInterface)

assertThat

@Nonnull
static <A extends LObjDoubleConsumerX<T,X>,T,X extends Throwable> LObjDoubleConsumerXAssert.The<A,T,X> assertThat(LObjDoubleConsumerX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjCharConsumer<T>,T> LObjCharConsumerAssert.The<A,T> assertThat(LObjCharConsumer<T> functionalInterface)

assertThat

@Nonnull
static <A extends LObjCharConsumerX<T,X>,T,X extends Throwable> LObjCharConsumerXAssert.The<A,T,X> assertThat(LObjCharConsumerX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjBoolConsumer<T>,T> LObjBoolConsumerAssert.The<A,T> assertThat(LObjBoolConsumer<T> functionalInterface)

assertThat

@Nonnull
static <A extends LObjBoolConsumerX<T,X>,T,X extends Throwable> LObjBoolConsumerXAssert.The<A,T,X> assertThat(LObjBoolConsumerX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjByteConsumer<T1,T2>,T1,T2> LBiObjByteConsumerAssert.The<A,T1,T2> assertThat(LBiObjByteConsumer<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjByteConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiObjByteConsumerXAssert.The<A,T1,T2,X> assertThat(LBiObjByteConsumerX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjShortConsumer<T1,T2>,T1,T2> LBiObjShortConsumerAssert.The<A,T1,T2> assertThat(LBiObjShortConsumer<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjShortConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiObjShortConsumerXAssert.The<A,T1,T2,X> assertThat(LBiObjShortConsumerX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjIntConsumer<T1,T2>,T1,T2> LBiObjIntConsumerAssert.The<A,T1,T2> assertThat(LBiObjIntConsumer<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjIntConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiObjIntConsumerXAssert.The<A,T1,T2,X> assertThat(LBiObjIntConsumerX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjLongConsumer<T1,T2>,T1,T2> LBiObjLongConsumerAssert.The<A,T1,T2> assertThat(LBiObjLongConsumer<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjLongConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiObjLongConsumerXAssert.The<A,T1,T2,X> assertThat(LBiObjLongConsumerX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjFloatConsumer<T1,T2>,T1,T2> LBiObjFloatConsumerAssert.The<A,T1,T2> assertThat(LBiObjFloatConsumer<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjFloatConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiObjFloatConsumerXAssert.The<A,T1,T2,X> assertThat(LBiObjFloatConsumerX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjDoubleConsumer<T1,T2>,T1,T2> LBiObjDoubleConsumerAssert.The<A,T1,T2> assertThat(LBiObjDoubleConsumer<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjDoubleConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiObjDoubleConsumerXAssert.The<A,T1,T2,X> assertThat(LBiObjDoubleConsumerX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjCharConsumer<T1,T2>,T1,T2> LBiObjCharConsumerAssert.The<A,T1,T2> assertThat(LBiObjCharConsumer<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjCharConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiObjCharConsumerXAssert.The<A,T1,T2,X> assertThat(LBiObjCharConsumerX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjBoolConsumer<T1,T2>,T1,T2> LBiObjBoolConsumerAssert.The<A,T1,T2> assertThat(LBiObjBoolConsumer<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjBoolConsumerX<T1,T2,X>,T1,T2,X extends Throwable> LBiObjBoolConsumerXAssert.The<A,T1,T2,X> assertThat(LBiObjBoolConsumerX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LUnaryOperator<T>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,T>,T> LUnaryOperatorAssert.The<A,RS,T> assertThat(LUnaryOperator<T> functionalInterface)

assertThat

@Nonnull
static <A extends LUnaryOperatorX<T,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,T>,T,X extends Throwable> LUnaryOperatorXAssert.The<A,RS,T,X> assertThat(LUnaryOperatorX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBinaryOperator<T>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,T>,T> LBinaryOperatorAssert.The<A,RS,T> assertThat(LBinaryOperator<T> functionalInterface)

assertThat

@Nonnull
static <A extends LBinaryOperatorX<T,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,T>,T,X extends Throwable> LBinaryOperatorXAssert.The<A,RS,T,X> assertThat(LBinaryOperatorX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LTernaryOperator<T>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,T>,T> LTernaryOperatorAssert.The<A,RS,T> assertThat(LTernaryOperator<T> functionalInterface)

assertThat

@Nonnull
static <A extends LTernaryOperatorX<T,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,T>,T,X extends Throwable> LTernaryOperatorXAssert.The<A,RS,T,X> assertThat(LTernaryOperatorX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LByteUnaryOperator,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LByteUnaryOperatorAssert.The<A,RS> assertThat(LByteUnaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends LByteUnaryOperatorX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LByteUnaryOperatorXAssert.The<A,RS,X> assertThat(LByteUnaryOperatorX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LShortUnaryOperator,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LShortUnaryOperatorAssert.The<A,RS> assertThat(LShortUnaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends LShortUnaryOperatorX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LShortUnaryOperatorXAssert.The<A,RS,X> assertThat(LShortUnaryOperatorX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LIntUnaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LIntUnaryOperatorAssert.The<A,RS> assertThat(LIntUnaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends LIntUnaryOperatorX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LIntUnaryOperatorXAssert.The<A,RS,X> assertThat(LIntUnaryOperatorX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LLongUnaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LLongUnaryOperatorAssert.The<A,RS> assertThat(LLongUnaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends LLongUnaryOperatorX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LLongUnaryOperatorXAssert.The<A,RS,X> assertThat(LLongUnaryOperatorX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LFloatUnaryOperator,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LFloatUnaryOperatorAssert.The<A,RS> assertThat(LFloatUnaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends LFloatUnaryOperatorX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LFloatUnaryOperatorXAssert.The<A,RS,X> assertThat(LFloatUnaryOperatorX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleUnaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LDoubleUnaryOperatorAssert.The<A,RS> assertThat(LDoubleUnaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleUnaryOperatorX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LDoubleUnaryOperatorXAssert.The<A,RS,X> assertThat(LDoubleUnaryOperatorX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LCharUnaryOperator,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LCharUnaryOperatorAssert.The<A,RS> assertThat(LCharUnaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends LCharUnaryOperatorX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LCharUnaryOperatorXAssert.The<A,RS,X> assertThat(LCharUnaryOperatorX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LLogicalOperator,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LLogicalOperatorAssert.The<A,RS> assertThat(LLogicalOperator functionalInterface)

assertThat

@Nonnull
static <A extends LLogicalOperatorX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LLogicalOperatorXAssert.The<A,RS,X> assertThat(LLogicalOperatorX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LByteBinaryOperator,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LByteBinaryOperatorAssert.The<A,RS> assertThat(LByteBinaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends LByteBinaryOperatorX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LByteBinaryOperatorXAssert.The<A,RS,X> assertThat(LByteBinaryOperatorX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LShortBinaryOperator,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LShortBinaryOperatorAssert.The<A,RS> assertThat(LShortBinaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends LShortBinaryOperatorX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LShortBinaryOperatorXAssert.The<A,RS,X> assertThat(LShortBinaryOperatorX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LIntBinaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LIntBinaryOperatorAssert.The<A,RS> assertThat(LIntBinaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends LIntBinaryOperatorX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LIntBinaryOperatorXAssert.The<A,RS,X> assertThat(LIntBinaryOperatorX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LLongBinaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LLongBinaryOperatorAssert.The<A,RS> assertThat(LLongBinaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends LLongBinaryOperatorX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LLongBinaryOperatorXAssert.The<A,RS,X> assertThat(LLongBinaryOperatorX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LFloatBinaryOperator,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LFloatBinaryOperatorAssert.The<A,RS> assertThat(LFloatBinaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends LFloatBinaryOperatorX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LFloatBinaryOperatorXAssert.The<A,RS,X> assertThat(LFloatBinaryOperatorX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleBinaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LDoubleBinaryOperatorAssert.The<A,RS> assertThat(LDoubleBinaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleBinaryOperatorX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LDoubleBinaryOperatorXAssert.The<A,RS,X> assertThat(LDoubleBinaryOperatorX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LCharBinaryOperator,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LCharBinaryOperatorAssert.The<A,RS> assertThat(LCharBinaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends LCharBinaryOperatorX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LCharBinaryOperatorXAssert.The<A,RS,X> assertThat(LCharBinaryOperatorX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LLogicalBinaryOperator,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LLogicalBinaryOperatorAssert.The<A,RS> assertThat(LLogicalBinaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends LLogicalBinaryOperatorX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LLogicalBinaryOperatorXAssert.The<A,RS,X> assertThat(LLogicalBinaryOperatorX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LLogicalTernaryOperator,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LLogicalTernaryOperatorAssert.The<A,RS> assertThat(LLogicalTernaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends LLogicalTernaryOperatorX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LLogicalTernaryOperatorXAssert.The<A,RS,X> assertThat(LLogicalTernaryOperatorX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LFunctionAssert.The<A,RS,T,R> assertThat(LFunction<T,R> functionalInterface)

assertThat

@Nonnull
static <A extends LFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LFunctionXAssert.The<A,RS,T,R,X> assertThat(LFunctionX<T,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiFunctionAssert.The<A,RS,T1,T2,R> assertThat(LBiFunction<T1,T2,R> functionalInterface)

assertThat

@Nonnull
static <A extends LBiFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiFunctionXAssert.The<A,RS,T1,T2,R,X> assertThat(LBiFunctionX<T1,T2,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LTriFunction<T1,T2,T3,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,T3,R> LTriFunctionAssert.The<A,RS,T1,T2,T3,R> assertThat(LTriFunction<T1,T2,T3,R> functionalInterface)

assertThat

@Nonnull
static <A extends LTriFunctionX<T1,T2,T3,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,T3,R,X extends Throwable> LTriFunctionXAssert.The<A,RS,T1,T2,T3,R,X> assertThat(LTriFunctionX<T1,T2,T3,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LByteFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LByteFunctionAssert.The<A,RS,R> assertThat(LByteFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends LByteFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LByteFunctionXAssert.The<A,RS,R,X> assertThat(LByteFunctionX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LShortFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LShortFunctionAssert.The<A,RS,R> assertThat(LShortFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends LShortFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LShortFunctionXAssert.The<A,RS,R,X> assertThat(LShortFunctionX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LIntFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LIntFunctionAssert.The<A,RS,R> assertThat(LIntFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends LIntFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LIntFunctionXAssert.The<A,RS,R,X> assertThat(LIntFunctionX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LLongFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LLongFunctionAssert.The<A,RS,R> assertThat(LLongFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends LLongFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LLongFunctionXAssert.The<A,RS,R,X> assertThat(LLongFunctionX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LFloatFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LFloatFunctionAssert.The<A,RS,R> assertThat(LFloatFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends LFloatFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LFloatFunctionXAssert.The<A,RS,R,X> assertThat(LFloatFunctionX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LDoubleFunctionAssert.The<A,RS,R> assertThat(LDoubleFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LDoubleFunctionXAssert.The<A,RS,R,X> assertThat(LDoubleFunctionX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LCharFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LCharFunctionAssert.The<A,RS,R> assertThat(LCharFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends LCharFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LCharFunctionXAssert.The<A,RS,R,X> assertThat(LCharFunctionX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBoolFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBoolFunctionAssert.The<A,RS,R> assertThat(LBoolFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends LBoolFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBoolFunctionXAssert.The<A,RS,R,X> assertThat(LBoolFunctionX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiByteFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBiByteFunctionAssert.The<A,RS,R> assertThat(LBiByteFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends LBiByteFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBiByteFunctionXAssert.The<A,RS,R,X> assertThat(LBiByteFunctionX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiShortFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBiShortFunctionAssert.The<A,RS,R> assertThat(LBiShortFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends LBiShortFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBiShortFunctionXAssert.The<A,RS,R,X> assertThat(LBiShortFunctionX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiIntFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBiIntFunctionAssert.The<A,RS,R> assertThat(LBiIntFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends LBiIntFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBiIntFunctionXAssert.The<A,RS,R,X> assertThat(LBiIntFunctionX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiLongFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBiLongFunctionAssert.The<A,RS,R> assertThat(LBiLongFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends LBiLongFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBiLongFunctionXAssert.The<A,RS,R,X> assertThat(LBiLongFunctionX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiFloatFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBiFloatFunctionAssert.The<A,RS,R> assertThat(LBiFloatFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends LBiFloatFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBiFloatFunctionXAssert.The<A,RS,R,X> assertThat(LBiFloatFunctionX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiDoubleFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBiDoubleFunctionAssert.The<A,RS,R> assertThat(LBiDoubleFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends LBiDoubleFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBiDoubleFunctionXAssert.The<A,RS,R,X> assertThat(LBiDoubleFunctionX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiCharFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBiCharFunctionAssert.The<A,RS,R> assertThat(LBiCharFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends LBiCharFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBiCharFunctionXAssert.The<A,RS,R,X> assertThat(LBiCharFunctionX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiBoolFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LBiBoolFunctionAssert.The<A,RS,R> assertThat(LBiBoolFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends LBiBoolFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LBiBoolFunctionXAssert.The<A,RS,R,X> assertThat(LBiBoolFunctionX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LTriBoolFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LTriBoolFunctionAssert.The<A,RS,R> assertThat(LTriBoolFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends LTriBoolFunctionX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LTriBoolFunctionXAssert.The<A,RS,R,X> assertThat(LTriBoolFunctionX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjByteFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LObjByteFunctionAssert.The<A,RS,T,R> assertThat(LObjByteFunction<T,R> functionalInterface)

assertThat

@Nonnull
static <A extends LObjByteFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LObjByteFunctionXAssert.The<A,RS,T,R,X> assertThat(LObjByteFunctionX<T,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjShortFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LObjShortFunctionAssert.The<A,RS,T,R> assertThat(LObjShortFunction<T,R> functionalInterface)

assertThat

@Nonnull
static <A extends LObjShortFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LObjShortFunctionXAssert.The<A,RS,T,R,X> assertThat(LObjShortFunctionX<T,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjIntFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LObjIntFunctionAssert.The<A,RS,T,R> assertThat(LObjIntFunction<T,R> functionalInterface)

assertThat

@Nonnull
static <A extends LObjIntFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LObjIntFunctionXAssert.The<A,RS,T,R,X> assertThat(LObjIntFunctionX<T,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjLongFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LObjLongFunctionAssert.The<A,RS,T,R> assertThat(LObjLongFunction<T,R> functionalInterface)

assertThat

@Nonnull
static <A extends LObjLongFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LObjLongFunctionXAssert.The<A,RS,T,R,X> assertThat(LObjLongFunctionX<T,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjFloatFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LObjFloatFunctionAssert.The<A,RS,T,R> assertThat(LObjFloatFunction<T,R> functionalInterface)

assertThat

@Nonnull
static <A extends LObjFloatFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LObjFloatFunctionXAssert.The<A,RS,T,R,X> assertThat(LObjFloatFunctionX<T,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjDoubleFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LObjDoubleFunctionAssert.The<A,RS,T,R> assertThat(LObjDoubleFunction<T,R> functionalInterface)

assertThat

@Nonnull
static <A extends LObjDoubleFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LObjDoubleFunctionXAssert.The<A,RS,T,R,X> assertThat(LObjDoubleFunctionX<T,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjCharFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LObjCharFunctionAssert.The<A,RS,T,R> assertThat(LObjCharFunction<T,R> functionalInterface)

assertThat

@Nonnull
static <A extends LObjCharFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LObjCharFunctionXAssert.The<A,RS,T,R,X> assertThat(LObjCharFunctionX<T,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjBoolFunction<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> LObjBoolFunctionAssert.The<A,RS,T,R> assertThat(LObjBoolFunction<T,R> functionalInterface)

assertThat

@Nonnull
static <A extends LObjBoolFunctionX<T,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R,X extends Throwable> LObjBoolFunctionXAssert.The<A,RS,T,R,X> assertThat(LObjBoolFunctionX<T,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjByteFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiObjByteFunctionAssert.The<A,RS,T1,T2,R> assertThat(LBiObjByteFunction<T1,T2,R> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjByteFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiObjByteFunctionXAssert.The<A,RS,T1,T2,R,X> assertThat(LBiObjByteFunctionX<T1,T2,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjShortFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiObjShortFunctionAssert.The<A,RS,T1,T2,R> assertThat(LBiObjShortFunction<T1,T2,R> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjShortFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiObjShortFunctionXAssert.The<A,RS,T1,T2,R,X> assertThat(LBiObjShortFunctionX<T1,T2,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjIntFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiObjIntFunctionAssert.The<A,RS,T1,T2,R> assertThat(LBiObjIntFunction<T1,T2,R> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjIntFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiObjIntFunctionXAssert.The<A,RS,T1,T2,R,X> assertThat(LBiObjIntFunctionX<T1,T2,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjLongFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiObjLongFunctionAssert.The<A,RS,T1,T2,R> assertThat(LBiObjLongFunction<T1,T2,R> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjLongFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiObjLongFunctionXAssert.The<A,RS,T1,T2,R,X> assertThat(LBiObjLongFunctionX<T1,T2,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjFloatFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiObjFloatFunctionAssert.The<A,RS,T1,T2,R> assertThat(LBiObjFloatFunction<T1,T2,R> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjFloatFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiObjFloatFunctionXAssert.The<A,RS,T1,T2,R,X> assertThat(LBiObjFloatFunctionX<T1,T2,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjDoubleFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiObjDoubleFunctionAssert.The<A,RS,T1,T2,R> assertThat(LBiObjDoubleFunction<T1,T2,R> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjDoubleFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiObjDoubleFunctionXAssert.The<A,RS,T1,T2,R,X> assertThat(LBiObjDoubleFunctionX<T1,T2,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjCharFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiObjCharFunctionAssert.The<A,RS,T1,T2,R> assertThat(LBiObjCharFunction<T1,T2,R> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjCharFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiObjCharFunctionXAssert.The<A,RS,T1,T2,R,X> assertThat(LBiObjCharFunctionX<T1,T2,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjBoolFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> LBiObjBoolFunctionAssert.The<A,RS,T1,T2,R> assertThat(LBiObjBoolFunction<T1,T2,R> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjBoolFunctionX<T1,T2,R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R,X extends Throwable> LBiObjBoolFunctionXAssert.The<A,RS,T1,T2,R,X> assertThat(LBiObjBoolFunctionX<T1,T2,R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LToByteFunction<T>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,T> LToByteFunctionAssert.The<A,RS,T> assertThat(LToByteFunction<T> functionalInterface)

assertThat

@Nonnull
static <A extends LToByteFunctionX<T,X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,T,X extends Throwable> LToByteFunctionXAssert.The<A,RS,T,X> assertThat(LToByteFunctionX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LToShortFunction<T>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,T> LToShortFunctionAssert.The<A,RS,T> assertThat(LToShortFunction<T> functionalInterface)

assertThat

@Nonnull
static <A extends LToShortFunctionX<T,X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,T,X extends Throwable> LToShortFunctionXAssert.The<A,RS,T,X> assertThat(LToShortFunctionX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LToIntFunction<T>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T> LToIntFunctionAssert.The<A,RS,T> assertThat(LToIntFunction<T> functionalInterface)

assertThat

@Nonnull
static <A extends LToIntFunctionX<T,X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T,X extends Throwable> LToIntFunctionXAssert.The<A,RS,T,X> assertThat(LToIntFunctionX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LToLongFunction<T>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T> LToLongFunctionAssert.The<A,RS,T> assertThat(LToLongFunction<T> functionalInterface)

assertThat

@Nonnull
static <A extends LToLongFunctionX<T,X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T,X extends Throwable> LToLongFunctionXAssert.The<A,RS,T,X> assertThat(LToLongFunctionX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LToFloatFunction<T>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,T> LToFloatFunctionAssert.The<A,RS,T> assertThat(LToFloatFunction<T> functionalInterface)

assertThat

@Nonnull
static <A extends LToFloatFunctionX<T,X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,T,X extends Throwable> LToFloatFunctionXAssert.The<A,RS,T,X> assertThat(LToFloatFunctionX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LToDoubleFunction<T>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T> LToDoubleFunctionAssert.The<A,RS,T> assertThat(LToDoubleFunction<T> functionalInterface)

assertThat

@Nonnull
static <A extends LToDoubleFunctionX<T,X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T,X extends Throwable> LToDoubleFunctionXAssert.The<A,RS,T,X> assertThat(LToDoubleFunctionX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LToCharFunction<T>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,T> LToCharFunctionAssert.The<A,RS,T> assertThat(LToCharFunction<T> functionalInterface)

assertThat

@Nonnull
static <A extends LToCharFunctionX<T,X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,T,X extends Throwable> LToCharFunctionXAssert.The<A,RS,T,X> assertThat(LToCharFunctionX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LToByteBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,T1,T2> LToByteBiFunctionAssert.The<A,RS,T1,T2> assertThat(LToByteBiFunction<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LToByteBiFunctionX<T1,T2,X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,T1,T2,X extends Throwable> LToByteBiFunctionXAssert.The<A,RS,T1,T2,X> assertThat(LToByteBiFunctionX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LToShortBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,T1,T2> LToShortBiFunctionAssert.The<A,RS,T1,T2> assertThat(LToShortBiFunction<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LToShortBiFunctionX<T1,T2,X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,T1,T2,X extends Throwable> LToShortBiFunctionXAssert.The<A,RS,T1,T2,X> assertThat(LToShortBiFunctionX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LToIntBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T1,T2> LToIntBiFunctionAssert.The<A,RS,T1,T2> assertThat(LToIntBiFunction<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LToIntBiFunctionX<T1,T2,X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T1,T2,X extends Throwable> LToIntBiFunctionXAssert.The<A,RS,T1,T2,X> assertThat(LToIntBiFunctionX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LToLongBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T1,T2> LToLongBiFunctionAssert.The<A,RS,T1,T2> assertThat(LToLongBiFunction<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LToLongBiFunctionX<T1,T2,X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T1,T2,X extends Throwable> LToLongBiFunctionXAssert.The<A,RS,T1,T2,X> assertThat(LToLongBiFunctionX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LToFloatBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,T1,T2> LToFloatBiFunctionAssert.The<A,RS,T1,T2> assertThat(LToFloatBiFunction<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LToFloatBiFunctionX<T1,T2,X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,T1,T2,X extends Throwable> LToFloatBiFunctionXAssert.The<A,RS,T1,T2,X> assertThat(LToFloatBiFunctionX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LToDoubleBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T1,T2> LToDoubleBiFunctionAssert.The<A,RS,T1,T2> assertThat(LToDoubleBiFunction<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LToDoubleBiFunctionX<T1,T2,X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T1,T2,X extends Throwable> LToDoubleBiFunctionXAssert.The<A,RS,T1,T2,X> assertThat(LToDoubleBiFunctionX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LToCharBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,T1,T2> LToCharBiFunctionAssert.The<A,RS,T1,T2> assertThat(LToCharBiFunction<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LToCharBiFunctionX<T1,T2,X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,T1,T2,X extends Throwable> LToCharBiFunctionXAssert.The<A,RS,T1,T2,X> assertThat(LToCharBiFunctionX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjIntToIntFunction<T>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T> LObjIntToIntFunctionAssert.The<A,RS,T> assertThat(LObjIntToIntFunction<T> functionalInterface)

assertThat

@Nonnull
static <A extends LObjIntToIntFunctionX<T,X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T,X extends Throwable> LObjIntToIntFunctionXAssert.The<A,RS,T,X> assertThat(LObjIntToIntFunctionX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LByteToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LByteToShortFunctionAssert.The<A,RS> assertThat(LByteToShortFunction functionalInterface)

assertThat

@Nonnull
static <A extends LByteToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LByteToShortFunctionXAssert.The<A,RS,X> assertThat(LByteToShortFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LByteToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LByteToIntFunctionAssert.The<A,RS> assertThat(LByteToIntFunction functionalInterface)

assertThat

@Nonnull
static <A extends LByteToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LByteToIntFunctionXAssert.The<A,RS,X> assertThat(LByteToIntFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LByteToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LByteToLongFunctionAssert.The<A,RS> assertThat(LByteToLongFunction functionalInterface)

assertThat

@Nonnull
static <A extends LByteToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LByteToLongFunctionXAssert.The<A,RS,X> assertThat(LByteToLongFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LByteToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LByteToFloatFunctionAssert.The<A,RS> assertThat(LByteToFloatFunction functionalInterface)

assertThat

@Nonnull
static <A extends LByteToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LByteToFloatFunctionXAssert.The<A,RS,X> assertThat(LByteToFloatFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LByteToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LByteToDoubleFunctionAssert.The<A,RS> assertThat(LByteToDoubleFunction functionalInterface)

assertThat

@Nonnull
static <A extends LByteToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LByteToDoubleFunctionXAssert.The<A,RS,X> assertThat(LByteToDoubleFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LByteToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LByteToCharFunctionAssert.The<A,RS> assertThat(LByteToCharFunction functionalInterface)

assertThat

@Nonnull
static <A extends LByteToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LByteToCharFunctionXAssert.The<A,RS,X> assertThat(LByteToCharFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LShortToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LShortToByteFunctionAssert.The<A,RS> assertThat(LShortToByteFunction functionalInterface)

assertThat

@Nonnull
static <A extends LShortToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LShortToByteFunctionXAssert.The<A,RS,X> assertThat(LShortToByteFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LShortToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LShortToIntFunctionAssert.The<A,RS> assertThat(LShortToIntFunction functionalInterface)

assertThat

@Nonnull
static <A extends LShortToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LShortToIntFunctionXAssert.The<A,RS,X> assertThat(LShortToIntFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LShortToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LShortToLongFunctionAssert.The<A,RS> assertThat(LShortToLongFunction functionalInterface)

assertThat

@Nonnull
static <A extends LShortToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LShortToLongFunctionXAssert.The<A,RS,X> assertThat(LShortToLongFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LShortToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LShortToFloatFunctionAssert.The<A,RS> assertThat(LShortToFloatFunction functionalInterface)

assertThat

@Nonnull
static <A extends LShortToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LShortToFloatFunctionXAssert.The<A,RS,X> assertThat(LShortToFloatFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LShortToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LShortToDoubleFunctionAssert.The<A,RS> assertThat(LShortToDoubleFunction functionalInterface)

assertThat

@Nonnull
static <A extends LShortToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LShortToDoubleFunctionXAssert.The<A,RS,X> assertThat(LShortToDoubleFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LShortToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LShortToCharFunctionAssert.The<A,RS> assertThat(LShortToCharFunction functionalInterface)

assertThat

@Nonnull
static <A extends LShortToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LShortToCharFunctionXAssert.The<A,RS,X> assertThat(LShortToCharFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LIntToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LIntToByteFunctionAssert.The<A,RS> assertThat(LIntToByteFunction functionalInterface)

assertThat

@Nonnull
static <A extends LIntToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LIntToByteFunctionXAssert.The<A,RS,X> assertThat(LIntToByteFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LIntToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LIntToShortFunctionAssert.The<A,RS> assertThat(LIntToShortFunction functionalInterface)

assertThat

@Nonnull
static <A extends LIntToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LIntToShortFunctionXAssert.The<A,RS,X> assertThat(LIntToShortFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LIntToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LIntToLongFunctionAssert.The<A,RS> assertThat(LIntToLongFunction functionalInterface)

assertThat

@Nonnull
static <A extends LIntToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LIntToLongFunctionXAssert.The<A,RS,X> assertThat(LIntToLongFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LIntToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LIntToFloatFunctionAssert.The<A,RS> assertThat(LIntToFloatFunction functionalInterface)

assertThat

@Nonnull
static <A extends LIntToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LIntToFloatFunctionXAssert.The<A,RS,X> assertThat(LIntToFloatFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LIntToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LIntToDoubleFunctionAssert.The<A,RS> assertThat(LIntToDoubleFunction functionalInterface)

assertThat

@Nonnull
static <A extends LIntToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LIntToDoubleFunctionXAssert.The<A,RS,X> assertThat(LIntToDoubleFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LIntToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LIntToCharFunctionAssert.The<A,RS> assertThat(LIntToCharFunction functionalInterface)

assertThat

@Nonnull
static <A extends LIntToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LIntToCharFunctionXAssert.The<A,RS,X> assertThat(LIntToCharFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LLongToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LLongToByteFunctionAssert.The<A,RS> assertThat(LLongToByteFunction functionalInterface)

assertThat

@Nonnull
static <A extends LLongToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LLongToByteFunctionXAssert.The<A,RS,X> assertThat(LLongToByteFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LLongToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LLongToShortFunctionAssert.The<A,RS> assertThat(LLongToShortFunction functionalInterface)

assertThat

@Nonnull
static <A extends LLongToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LLongToShortFunctionXAssert.The<A,RS,X> assertThat(LLongToShortFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LLongToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LLongToIntFunctionAssert.The<A,RS> assertThat(LLongToIntFunction functionalInterface)

assertThat

@Nonnull
static <A extends LLongToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LLongToIntFunctionXAssert.The<A,RS,X> assertThat(LLongToIntFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LLongToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LLongToFloatFunctionAssert.The<A,RS> assertThat(LLongToFloatFunction functionalInterface)

assertThat

@Nonnull
static <A extends LLongToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LLongToFloatFunctionXAssert.The<A,RS,X> assertThat(LLongToFloatFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LLongToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LLongToDoubleFunctionAssert.The<A,RS> assertThat(LLongToDoubleFunction functionalInterface)

assertThat

@Nonnull
static <A extends LLongToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LLongToDoubleFunctionXAssert.The<A,RS,X> assertThat(LLongToDoubleFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LLongToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LLongToCharFunctionAssert.The<A,RS> assertThat(LLongToCharFunction functionalInterface)

assertThat

@Nonnull
static <A extends LLongToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LLongToCharFunctionXAssert.The<A,RS,X> assertThat(LLongToCharFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LFloatToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LFloatToByteFunctionAssert.The<A,RS> assertThat(LFloatToByteFunction functionalInterface)

assertThat

@Nonnull
static <A extends LFloatToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LFloatToByteFunctionXAssert.The<A,RS,X> assertThat(LFloatToByteFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LFloatToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LFloatToShortFunctionAssert.The<A,RS> assertThat(LFloatToShortFunction functionalInterface)

assertThat

@Nonnull
static <A extends LFloatToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LFloatToShortFunctionXAssert.The<A,RS,X> assertThat(LFloatToShortFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LFloatToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LFloatToIntFunctionAssert.The<A,RS> assertThat(LFloatToIntFunction functionalInterface)

assertThat

@Nonnull
static <A extends LFloatToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LFloatToIntFunctionXAssert.The<A,RS,X> assertThat(LFloatToIntFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LFloatToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LFloatToLongFunctionAssert.The<A,RS> assertThat(LFloatToLongFunction functionalInterface)

assertThat

@Nonnull
static <A extends LFloatToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LFloatToLongFunctionXAssert.The<A,RS,X> assertThat(LFloatToLongFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LFloatToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LFloatToDoubleFunctionAssert.The<A,RS> assertThat(LFloatToDoubleFunction functionalInterface)

assertThat

@Nonnull
static <A extends LFloatToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LFloatToDoubleFunctionXAssert.The<A,RS,X> assertThat(LFloatToDoubleFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LFloatToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LFloatToCharFunctionAssert.The<A,RS> assertThat(LFloatToCharFunction functionalInterface)

assertThat

@Nonnull
static <A extends LFloatToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LFloatToCharFunctionXAssert.The<A,RS,X> assertThat(LFloatToCharFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LDoubleToByteFunctionAssert.The<A,RS> assertThat(LDoubleToByteFunction functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LDoubleToByteFunctionXAssert.The<A,RS,X> assertThat(LDoubleToByteFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LDoubleToShortFunctionAssert.The<A,RS> assertThat(LDoubleToShortFunction functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LDoubleToShortFunctionXAssert.The<A,RS,X> assertThat(LDoubleToShortFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LDoubleToIntFunctionAssert.The<A,RS> assertThat(LDoubleToIntFunction functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LDoubleToIntFunctionXAssert.The<A,RS,X> assertThat(LDoubleToIntFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LDoubleToLongFunctionAssert.The<A,RS> assertThat(LDoubleToLongFunction functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LDoubleToLongFunctionXAssert.The<A,RS,X> assertThat(LDoubleToLongFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LDoubleToFloatFunctionAssert.The<A,RS> assertThat(LDoubleToFloatFunction functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LDoubleToFloatFunctionXAssert.The<A,RS,X> assertThat(LDoubleToFloatFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LDoubleToCharFunctionAssert.The<A,RS> assertThat(LDoubleToCharFunction functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LDoubleToCharFunctionXAssert.The<A,RS,X> assertThat(LDoubleToCharFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LCharToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LCharToByteFunctionAssert.The<A,RS> assertThat(LCharToByteFunction functionalInterface)

assertThat

@Nonnull
static <A extends LCharToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LCharToByteFunctionXAssert.The<A,RS,X> assertThat(LCharToByteFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LCharToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LCharToShortFunctionAssert.The<A,RS> assertThat(LCharToShortFunction functionalInterface)

assertThat

@Nonnull
static <A extends LCharToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LCharToShortFunctionXAssert.The<A,RS,X> assertThat(LCharToShortFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LCharToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LCharToIntFunctionAssert.The<A,RS> assertThat(LCharToIntFunction functionalInterface)

assertThat

@Nonnull
static <A extends LCharToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LCharToIntFunctionXAssert.The<A,RS,X> assertThat(LCharToIntFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LCharToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LCharToLongFunctionAssert.The<A,RS> assertThat(LCharToLongFunction functionalInterface)

assertThat

@Nonnull
static <A extends LCharToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LCharToLongFunctionXAssert.The<A,RS,X> assertThat(LCharToLongFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LCharToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LCharToFloatFunctionAssert.The<A,RS> assertThat(LCharToFloatFunction functionalInterface)

assertThat

@Nonnull
static <A extends LCharToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LCharToFloatFunctionXAssert.The<A,RS,X> assertThat(LCharToFloatFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LCharToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LCharToDoubleFunctionAssert.The<A,RS> assertThat(LCharToDoubleFunction functionalInterface)

assertThat

@Nonnull
static <A extends LCharToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LCharToDoubleFunctionXAssert.The<A,RS,X> assertThat(LCharToDoubleFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBoolToByteFunction,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LBoolToByteFunctionAssert.The<A,RS> assertThat(LBoolToByteFunction functionalInterface)

assertThat

@Nonnull
static <A extends LBoolToByteFunctionX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LBoolToByteFunctionXAssert.The<A,RS,X> assertThat(LBoolToByteFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBoolToShortFunction,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LBoolToShortFunctionAssert.The<A,RS> assertThat(LBoolToShortFunction functionalInterface)

assertThat

@Nonnull
static <A extends LBoolToShortFunctionX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LBoolToShortFunctionXAssert.The<A,RS,X> assertThat(LBoolToShortFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBoolToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LBoolToIntFunctionAssert.The<A,RS> assertThat(LBoolToIntFunction functionalInterface)

assertThat

@Nonnull
static <A extends LBoolToIntFunctionX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LBoolToIntFunctionXAssert.The<A,RS,X> assertThat(LBoolToIntFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBoolToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LBoolToLongFunctionAssert.The<A,RS> assertThat(LBoolToLongFunction functionalInterface)

assertThat

@Nonnull
static <A extends LBoolToLongFunctionX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LBoolToLongFunctionXAssert.The<A,RS,X> assertThat(LBoolToLongFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBoolToFloatFunction,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LBoolToFloatFunctionAssert.The<A,RS> assertThat(LBoolToFloatFunction functionalInterface)

assertThat

@Nonnull
static <A extends LBoolToFloatFunctionX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LBoolToFloatFunctionXAssert.The<A,RS,X> assertThat(LBoolToFloatFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBoolToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LBoolToDoubleFunctionAssert.The<A,RS> assertThat(LBoolToDoubleFunction functionalInterface)

assertThat

@Nonnull
static <A extends LBoolToDoubleFunctionX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LBoolToDoubleFunctionXAssert.The<A,RS,X> assertThat(LBoolToDoubleFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBoolToCharFunction,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LBoolToCharFunctionAssert.The<A,RS> assertThat(LBoolToCharFunction functionalInterface)

assertThat

@Nonnull
static <A extends LBoolToCharFunctionX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LBoolToCharFunctionXAssert.The<A,RS,X> assertThat(LBoolToCharFunctionX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LPredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LPredicateAssert.The<A,RS,T> assertThat(LPredicate<T> functionalInterface)

assertThat

@Nonnull
static <A extends LPredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LPredicateXAssert.The<A,RS,T,X> assertThat(LPredicateX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiPredicateAssert.The<A,RS,T1,T2> assertThat(LBiPredicate<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiPredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiPredicateXAssert.The<A,RS,T1,T2,X> assertThat(LBiPredicateX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LTriPredicate<T1,T2,T3>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,T3> LTriPredicateAssert.The<A,RS,T1,T2,T3> assertThat(LTriPredicate<T1,T2,T3> functionalInterface)

assertThat

@Nonnull
static <A extends LTriPredicateX<T1,T2,T3,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,T3,X extends Throwable> LTriPredicateXAssert.The<A,RS,T1,T2,T3,X> assertThat(LTriPredicateX<T1,T2,T3,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBytePredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBytePredicateAssert.The<A,RS> assertThat(LBytePredicate functionalInterface)

assertThat

@Nonnull
static <A extends LBytePredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBytePredicateXAssert.The<A,RS,X> assertThat(LBytePredicateX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LShortPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LShortPredicateAssert.The<A,RS> assertThat(LShortPredicate functionalInterface)

assertThat

@Nonnull
static <A extends LShortPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LShortPredicateXAssert.The<A,RS,X> assertThat(LShortPredicateX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LIntPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LIntPredicateAssert.The<A,RS> assertThat(LIntPredicate functionalInterface)

assertThat

@Nonnull
static <A extends LIntPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LIntPredicateXAssert.The<A,RS,X> assertThat(LIntPredicateX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LLongPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LLongPredicateAssert.The<A,RS> assertThat(LLongPredicate functionalInterface)

assertThat

@Nonnull
static <A extends LLongPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LLongPredicateXAssert.The<A,RS,X> assertThat(LLongPredicateX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LFloatPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LFloatPredicateAssert.The<A,RS> assertThat(LFloatPredicate functionalInterface)

assertThat

@Nonnull
static <A extends LFloatPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LFloatPredicateXAssert.The<A,RS,X> assertThat(LFloatPredicateX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LDoublePredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LDoublePredicateAssert.The<A,RS> assertThat(LDoublePredicate functionalInterface)

assertThat

@Nonnull
static <A extends LDoublePredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LDoublePredicateXAssert.The<A,RS,X> assertThat(LDoublePredicateX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LCharPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LCharPredicateAssert.The<A,RS> assertThat(LCharPredicate functionalInterface)

assertThat

@Nonnull
static <A extends LCharPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LCharPredicateXAssert.The<A,RS,X> assertThat(LCharPredicateX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiBytePredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBiBytePredicateAssert.The<A,RS> assertThat(LBiBytePredicate functionalInterface)

assertThat

@Nonnull
static <A extends LBiBytePredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBiBytePredicateXAssert.The<A,RS,X> assertThat(LBiBytePredicateX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiShortPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBiShortPredicateAssert.The<A,RS> assertThat(LBiShortPredicate functionalInterface)

assertThat

@Nonnull
static <A extends LBiShortPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBiShortPredicateXAssert.The<A,RS,X> assertThat(LBiShortPredicateX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiIntPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBiIntPredicateAssert.The<A,RS> assertThat(LBiIntPredicate functionalInterface)

assertThat

@Nonnull
static <A extends LBiIntPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBiIntPredicateXAssert.The<A,RS,X> assertThat(LBiIntPredicateX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiLongPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBiLongPredicateAssert.The<A,RS> assertThat(LBiLongPredicate functionalInterface)

assertThat

@Nonnull
static <A extends LBiLongPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBiLongPredicateXAssert.The<A,RS,X> assertThat(LBiLongPredicateX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiFloatPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBiFloatPredicateAssert.The<A,RS> assertThat(LBiFloatPredicate functionalInterface)

assertThat

@Nonnull
static <A extends LBiFloatPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBiFloatPredicateXAssert.The<A,RS,X> assertThat(LBiFloatPredicateX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiDoublePredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBiDoublePredicateAssert.The<A,RS> assertThat(LBiDoublePredicate functionalInterface)

assertThat

@Nonnull
static <A extends LBiDoublePredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBiDoublePredicateXAssert.The<A,RS,X> assertThat(LBiDoublePredicateX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiCharPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBiCharPredicateAssert.The<A,RS> assertThat(LBiCharPredicate functionalInterface)

assertThat

@Nonnull
static <A extends LBiCharPredicateX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBiCharPredicateXAssert.The<A,RS,X> assertThat(LBiCharPredicateX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjBytePredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LObjBytePredicateAssert.The<A,RS,T> assertThat(LObjBytePredicate<T> functionalInterface)

assertThat

@Nonnull
static <A extends LObjBytePredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LObjBytePredicateXAssert.The<A,RS,T,X> assertThat(LObjBytePredicateX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjShortPredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LObjShortPredicateAssert.The<A,RS,T> assertThat(LObjShortPredicate<T> functionalInterface)

assertThat

@Nonnull
static <A extends LObjShortPredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LObjShortPredicateXAssert.The<A,RS,T,X> assertThat(LObjShortPredicateX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjIntPredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LObjIntPredicateAssert.The<A,RS,T> assertThat(LObjIntPredicate<T> functionalInterface)

assertThat

@Nonnull
static <A extends LObjIntPredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LObjIntPredicateXAssert.The<A,RS,T,X> assertThat(LObjIntPredicateX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjLongPredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LObjLongPredicateAssert.The<A,RS,T> assertThat(LObjLongPredicate<T> functionalInterface)

assertThat

@Nonnull
static <A extends LObjLongPredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LObjLongPredicateXAssert.The<A,RS,T,X> assertThat(LObjLongPredicateX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjFloatPredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LObjFloatPredicateAssert.The<A,RS,T> assertThat(LObjFloatPredicate<T> functionalInterface)

assertThat

@Nonnull
static <A extends LObjFloatPredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LObjFloatPredicateXAssert.The<A,RS,T,X> assertThat(LObjFloatPredicateX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjDoublePredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LObjDoublePredicateAssert.The<A,RS,T> assertThat(LObjDoublePredicate<T> functionalInterface)

assertThat

@Nonnull
static <A extends LObjDoublePredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LObjDoublePredicateXAssert.The<A,RS,T,X> assertThat(LObjDoublePredicateX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjCharPredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LObjCharPredicateAssert.The<A,RS,T> assertThat(LObjCharPredicate<T> functionalInterface)

assertThat

@Nonnull
static <A extends LObjCharPredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LObjCharPredicateXAssert.The<A,RS,T,X> assertThat(LObjCharPredicateX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LObjBoolPredicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> LObjBoolPredicateAssert.The<A,RS,T> assertThat(LObjBoolPredicate<T> functionalInterface)

assertThat

@Nonnull
static <A extends LObjBoolPredicateX<T,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T,X extends Throwable> LObjBoolPredicateXAssert.The<A,RS,T,X> assertThat(LObjBoolPredicateX<T,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjBytePredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiObjBytePredicateAssert.The<A,RS,T1,T2> assertThat(LBiObjBytePredicate<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjBytePredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiObjBytePredicateXAssert.The<A,RS,T1,T2,X> assertThat(LBiObjBytePredicateX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjShortPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiObjShortPredicateAssert.The<A,RS,T1,T2> assertThat(LBiObjShortPredicate<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjShortPredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiObjShortPredicateXAssert.The<A,RS,T1,T2,X> assertThat(LBiObjShortPredicateX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjIntPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiObjIntPredicateAssert.The<A,RS,T1,T2> assertThat(LBiObjIntPredicate<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjIntPredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiObjIntPredicateXAssert.The<A,RS,T1,T2,X> assertThat(LBiObjIntPredicateX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjLongPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiObjLongPredicateAssert.The<A,RS,T1,T2> assertThat(LBiObjLongPredicate<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjLongPredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiObjLongPredicateXAssert.The<A,RS,T1,T2,X> assertThat(LBiObjLongPredicateX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjFloatPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiObjFloatPredicateAssert.The<A,RS,T1,T2> assertThat(LBiObjFloatPredicate<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjFloatPredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiObjFloatPredicateXAssert.The<A,RS,T1,T2,X> assertThat(LBiObjFloatPredicateX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjDoublePredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiObjDoublePredicateAssert.The<A,RS,T1,T2> assertThat(LBiObjDoublePredicate<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjDoublePredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiObjDoublePredicateXAssert.The<A,RS,T1,T2,X> assertThat(LBiObjDoublePredicateX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjCharPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiObjCharPredicateAssert.The<A,RS,T1,T2> assertThat(LBiObjCharPredicate<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjCharPredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiObjCharPredicateXAssert.The<A,RS,T1,T2,X> assertThat(LBiObjCharPredicateX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjBoolPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> LBiObjBoolPredicateAssert.The<A,RS,T1,T2> assertThat(LBiObjBoolPredicate<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends LBiObjBoolPredicateX<T1,T2,X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2,X extends Throwable> LBiObjBoolPredicateXAssert.The<A,RS,T1,T2,X> assertThat(LBiObjBoolPredicateX<T1,T2,X> functionalInterface)

assertThat

@Nonnull
static <A extends LSupplier<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LSupplierAssert.The<A,RS,R> assertThat(LSupplier<R> functionalInterface)

assertThat

@Nonnull
static <A extends LSupplierX<R,X>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R,X extends Throwable> LSupplierXAssert.The<A,RS,R,X> assertThat(LSupplierX<R,X> functionalInterface)

assertThat

@Nonnull
static <A extends LByteSupplier,RS extends org.assertj.core.api.AbstractByteAssert<RS>> LByteSupplierAssert.The<A,RS> assertThat(LByteSupplier functionalInterface)

assertThat

@Nonnull
static <A extends LByteSupplierX<X>,RS extends org.assertj.core.api.AbstractByteAssert<RS>,X extends Throwable> LByteSupplierXAssert.The<A,RS,X> assertThat(LByteSupplierX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LShortSupplier,RS extends org.assertj.core.api.AbstractShortAssert<RS>> LShortSupplierAssert.The<A,RS> assertThat(LShortSupplier functionalInterface)

assertThat

@Nonnull
static <A extends LShortSupplierX<X>,RS extends org.assertj.core.api.AbstractShortAssert<RS>,X extends Throwable> LShortSupplierXAssert.The<A,RS,X> assertThat(LShortSupplierX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LIntSupplier,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LIntSupplierAssert.The<A,RS> assertThat(LIntSupplier functionalInterface)

assertThat

@Nonnull
static <A extends LIntSupplierX<X>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,X extends Throwable> LIntSupplierXAssert.The<A,RS,X> assertThat(LIntSupplierX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LLongSupplier,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LLongSupplierAssert.The<A,RS> assertThat(LLongSupplier functionalInterface)

assertThat

@Nonnull
static <A extends LLongSupplierX<X>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,X extends Throwable> LLongSupplierXAssert.The<A,RS,X> assertThat(LLongSupplierX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LFloatSupplier,RS extends org.assertj.core.api.AbstractFloatAssert<RS>> LFloatSupplierAssert.The<A,RS> assertThat(LFloatSupplier functionalInterface)

assertThat

@Nonnull
static <A extends LFloatSupplierX<X>,RS extends org.assertj.core.api.AbstractFloatAssert<RS>,X extends Throwable> LFloatSupplierXAssert.The<A,RS,X> assertThat(LFloatSupplierX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleSupplier,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LDoubleSupplierAssert.The<A,RS> assertThat(LDoubleSupplier functionalInterface)

assertThat

@Nonnull
static <A extends LDoubleSupplierX<X>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,X extends Throwable> LDoubleSupplierXAssert.The<A,RS,X> assertThat(LDoubleSupplierX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LCharSupplier,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>> LCharSupplierAssert.The<A,RS> assertThat(LCharSupplier functionalInterface)

assertThat

@Nonnull
static <A extends LCharSupplierX<X>,RS extends org.assertj.core.api.AbstractCharacterAssert<RS>,X extends Throwable> LCharSupplierXAssert.The<A,RS,X> assertThat(LCharSupplierX<X> functionalInterface)

assertThat

@Nonnull
static <A extends LBoolSupplier,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LBoolSupplierAssert.The<A,RS> assertThat(LBoolSupplier functionalInterface)

assertThat

@Nonnull
static <A extends LBoolSupplierX<X>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,X extends Throwable> LBoolSupplierXAssert.The<A,RS,X> assertThat(LBoolSupplierX<X> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.UnaryOperator<T>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,T>,T> UnaryOperatorAssert.The<A,RS,T> assertThat(java.util.function.UnaryOperator<T> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.BinaryOperator<T>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,T>,T> BinaryOperatorAssert.The<A,RS,T> assertThat(java.util.function.BinaryOperator<T> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.IntUnaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> IntUnaryOperatorAssert.The<A,RS> assertThat(java.util.function.IntUnaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.LongUnaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LongUnaryOperatorAssert.The<A,RS> assertThat(java.util.function.LongUnaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.DoubleUnaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> DoubleUnaryOperatorAssert.The<A,RS> assertThat(java.util.function.DoubleUnaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.IntBinaryOperator,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> IntBinaryOperatorAssert.The<A,RS> assertThat(java.util.function.IntBinaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.LongBinaryOperator,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LongBinaryOperatorAssert.The<A,RS> assertThat(java.util.function.LongBinaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.DoubleBinaryOperator,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> DoubleBinaryOperatorAssert.The<A,RS> assertThat(java.util.function.DoubleBinaryOperator functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.Function<T,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T,R> FunctionAssert.The<A,RS,T,R> assertThat(java.util.function.Function<T,R> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.BiFunction<T1,T2,R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,T1,T2,R> BiFunctionAssert.The<A,RS,T1,T2,R> assertThat(java.util.function.BiFunction<T1,T2,R> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.IntFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> IntFunctionAssert.The<A,RS,R> assertThat(java.util.function.IntFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.LongFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> LongFunctionAssert.The<A,RS,R> assertThat(java.util.function.LongFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.DoubleFunction<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> DoubleFunctionAssert.The<A,RS,R> assertThat(java.util.function.DoubleFunction<R> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.ToIntFunction<T>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T> ToIntFunctionAssert.The<A,RS,T> assertThat(java.util.function.ToIntFunction<T> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.ToLongFunction<T>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T> ToLongFunctionAssert.The<A,RS,T> assertThat(java.util.function.ToLongFunction<T> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.ToDoubleFunction<T>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T> ToDoubleFunctionAssert.The<A,RS,T> assertThat(java.util.function.ToDoubleFunction<T> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.ToIntBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>,T1,T2> ToIntBiFunctionAssert.The<A,RS,T1,T2> assertThat(java.util.function.ToIntBiFunction<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.ToLongBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractLongAssert<RS>,T1,T2> ToLongBiFunctionAssert.The<A,RS,T1,T2> assertThat(java.util.function.ToLongBiFunction<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.ToDoubleBiFunction<T1,T2>,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>,T1,T2> ToDoubleBiFunctionAssert.The<A,RS,T1,T2> assertThat(java.util.function.ToDoubleBiFunction<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.IntToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> IntToLongFunctionAssert.The<A,RS> assertThat(java.util.function.IntToLongFunction functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.IntToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> IntToDoubleFunctionAssert.The<A,RS> assertThat(java.util.function.IntToDoubleFunction functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.LongToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> LongToIntFunctionAssert.The<A,RS> assertThat(java.util.function.LongToIntFunction functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.LongToDoubleFunction,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> LongToDoubleFunctionAssert.The<A,RS> assertThat(java.util.function.LongToDoubleFunction functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.DoubleToIntFunction,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> DoubleToIntFunctionAssert.The<A,RS> assertThat(java.util.function.DoubleToIntFunction functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.DoubleToLongFunction,RS extends org.assertj.core.api.AbstractLongAssert<RS>> DoubleToLongFunctionAssert.The<A,RS> assertThat(java.util.function.DoubleToLongFunction functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.Predicate<T>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T> PredicateAssert.The<A,RS,T> assertThat(java.util.function.Predicate<T> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.BiPredicate<T1,T2>,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>,T1,T2> BiPredicateAssert.The<A,RS,T1,T2> assertThat(java.util.function.BiPredicate<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.IntPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> IntPredicateAssert.The<A,RS> assertThat(java.util.function.IntPredicate functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.LongPredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> LongPredicateAssert.The<A,RS> assertThat(java.util.function.LongPredicate functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.DoublePredicate,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> DoublePredicateAssert.The<A,RS> assertThat(java.util.function.DoublePredicate functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.Supplier<R>,RS extends org.assertj.core.api.AbstractObjectAssert<RS,R>,R> SupplierAssert.The<A,RS,R> assertThat(java.util.function.Supplier<R> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.IntSupplier,RS extends org.assertj.core.api.AbstractIntegerAssert<RS>> IntSupplierAssert.The<A,RS> assertThat(java.util.function.IntSupplier functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.LongSupplier,RS extends org.assertj.core.api.AbstractLongAssert<RS>> LongSupplierAssert.The<A,RS> assertThat(java.util.function.LongSupplier functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.DoubleSupplier,RS extends org.assertj.core.api.AbstractDoubleAssert<RS>> DoubleSupplierAssert.The<A,RS> assertThat(java.util.function.DoubleSupplier functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.BooleanSupplier,RS extends org.assertj.core.api.AbstractBooleanAssert<RS>> BooleanSupplierAssert.The<A,RS> assertThat(java.util.function.BooleanSupplier functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.Consumer<T>,T> ConsumerAssert.The<A,T> assertThat(java.util.function.Consumer<T> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.BiConsumer<T1,T2>,T1,T2> BiConsumerAssert.The<A,T1,T2> assertThat(java.util.function.BiConsumer<T1,T2> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.IntConsumer> IntConsumerAssert.The<A> assertThat(java.util.function.IntConsumer functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.LongConsumer> LongConsumerAssert.The<A> assertThat(java.util.function.LongConsumer functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.DoubleConsumer> DoubleConsumerAssert.The<A> assertThat(java.util.function.DoubleConsumer functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.ObjIntConsumer<T>,T> ObjIntConsumerAssert.The<A,T> assertThat(java.util.function.ObjIntConsumer<T> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.ObjLongConsumer<T>,T> ObjLongConsumerAssert.The<A,T> assertThat(java.util.function.ObjLongConsumer<T> functionalInterface)

assertThat

@Nonnull
static <A extends java.util.function.ObjDoubleConsumer<T>,T> ObjDoubleConsumerAssert.The<A,T> assertThat(java.util.function.ObjDoubleConsumer<T> functionalInterface)