Increase test coverage of functional interfaces

src/test/java/org/apache/commons/lang3/function/FailableDoubleFunctionTest.java

@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+/**
+ * Tests {@link FailableDoubleFunction}.
+ */
+public class FailableDoubleFunctionTest {
+    @Test
+    public void testNop() throws Throwable {
+        final FailableDoubleFunction<Object, Throwable> func = FailableDoubleFunction.nop();
+        assertNull(func.apply(Double.MAX_VALUE), "Expect NOP to return null");
+    }
+}

src/test/java/org/apache/commons/lang3/function/FailableDoubleToIntFunctionTest.java

@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Tests {@link FailableDoubleToIntFunction}.
+ */
+public class FailableDoubleToIntFunctionTest {
+    @Test
+    public void testNop() throws Throwable {
+        final FailableDoubleToIntFunction<Throwable> func = FailableDoubleToIntFunction.nop();
+        assertEquals(0, func.applyAsInt(Double.MAX_VALUE), "Expect NOP to return default value of 0");
+    }
+}

src/test/java/org/apache/commons/lang3/function/FailableDoubleToLongFunctionTest.java

@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Tests {@link FailableDoubleToLongFunction}.
+ */
+public class FailableDoubleToLongFunctionTest {
+    @Test
+    public void testNop() throws Throwable {
+        final FailableDoubleToLongFunction<Throwable> func = FailableDoubleToLongFunction.nop();
+        assertEquals(0, func.applyAsLong(Double.MAX_VALUE), "Expect NOP to return default value of 0");
+    }
+}

src/test/java/org/apache/commons/lang3/function/FailableFunctionsTest.java

@@ -1351,6 +1351,17 @@ public class FailableFunctionsTest {
         assertThrows(NullPointerException.class, () -> assertTrue(FailablePredicate.TRUE.and(null).test(null)));
     }
 
+    @Test
+    public void testPredicateOr() throws Throwable {
+        assertTrue(FailablePredicate.TRUE.or(FailablePredicate.TRUE).test(null));
+        assertTrue(FailablePredicate.TRUE.or(FailablePredicate.FALSE).test(null));
+        assertTrue(FailablePredicate.FALSE.or(FailablePredicate.TRUE).test(null));
+        assertFalse(FailablePredicate.FALSE.or(FailablePredicate.FALSE).test(null));
+        // null tests
+        assertThrows(NullPointerException.class, () -> assertFalse(FailablePredicate.FALSE.or(null).test(null)));
+        assertThrows(NullPointerException.class, () -> assertTrue(FailablePredicate.TRUE.or(null).test(null)));
+    }
+
     @Test
     public void testPredicateNegate() throws Throwable {
         assertFalse(FailablePredicate.TRUE.negate().test(null));

src/test/java/org/apache/commons/lang3/function/FailableIntFunctionTest.java

@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+/**
+ * Tests {@link FailableIntFunction}.
+ */
+public class FailableIntFunctionTest {
+    @Test
+    public void testNop() throws Throwable {
+        final FailableIntFunction<Object, Throwable> func = FailableIntFunction.nop();
+        assertNull(func.apply(Integer.MAX_VALUE), "Expect NOP to return null");
+    }
+}

src/test/java/org/apache/commons/lang3/function/FailableIntToDoubleFunctionTest.java

@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Tests {@link FailableIntToDoubleFunction}.
+ */
+public class FailableIntToDoubleFunctionTest {
+    @Test
+    public void testNop() throws Throwable {
+        final FailableIntToDoubleFunction<Throwable> func = FailableIntToDoubleFunction.nop();
+        assertEquals(0, func.applyAsDouble(Integer.MAX_VALUE), "Expect NOP to return 0");
+    }
+}

src/test/java/org/apache/commons/lang3/function/FailableIntToLongFunctionTest.java

@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Tests {@link FailableIntToLongFunction}.
+ */
+public class FailableIntToLongFunctionTest {
+    @Test
+    public void testNop() throws Throwable {
+        final FailableIntToLongFunction<Throwable> func = FailableIntToLongFunction.nop();
+        assertEquals(0, func.applyAsLong(Integer.MAX_VALUE), "Expect NOP to return 0");
+    }
+}

src/test/java/org/apache/commons/lang3/function/FailableLongFunctionTest.java

@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+/**
+ * Tests {@link FailableLongFunction}.
+ */
+public class FailableLongFunctionTest {
+    @Test
+    public void testNop() throws Throwable {
+        final FailableLongFunction<Object, Throwable> func = FailableLongFunction.nop();
+        assertNull(func.apply(Long.MAX_VALUE), "Expect NOP to return null");
+    }
+}

src/test/java/org/apache/commons/lang3/function/FailableLongToDoubleFunctionTest.java

@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Tests {@link FailableLongToDoubleFunction}.
+ */
+public class FailableLongToDoubleFunctionTest {
+    @Test
+    public void testNop() throws Throwable {
+        final FailableLongToDoubleFunction<Throwable> func = FailableLongToDoubleFunction.nop();
+        assertEquals(0, func.applyAsDouble(Long.MAX_VALUE), "Expect NOP to return 0");
+    }
+}

src/test/java/org/apache/commons/lang3/function/FailableLongToIntFunctionTest.java

@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Tests {@link FailableLongToIntFunction}.
+ */
+public class FailableLongToIntFunctionTest {
+    @Test
+    public void testNop() throws Throwable {
+        final FailableLongToIntFunction<Throwable> func = FailableLongToIntFunction.nop();
+        assertEquals(0, func.applyAsInt(Long.MAX_VALUE), "Expect NOP to return 0");
+    }
+}

src/test/java/org/apache/commons/lang3/function/FailableObjDoubleConsumerTest.java

@@ -0,0 +1,37 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+/**
+ * Tests {@link FailableObjDoubleConsumer}.
+ */
+public class FailableObjDoubleConsumerTest {
+    @Test
+    public void testNop() {
+        final FailableObjDoubleConsumer<Object, Throwable> func = FailableObjDoubleConsumer.nop();
+        try {
+            func.accept("FOO", Double.MAX_VALUE);
+        } catch (final Throwable e) {
+            fail("Accepting NOP must not throw an exception");
+        }
+    }
+}

src/test/java/org/apache/commons/lang3/function/FailableObjIntConsumerTest.java

@@ -0,0 +1,37 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+/**
+ * Tests {@link FailableObjIntConsumer}.
+ */
+public class FailableObjIntConsumerTest {
+    @Test
+    public void testNop() {
+        final FailableObjIntConsumer<Object, Throwable> func = FailableObjIntConsumer.nop();
+        try {
+            func.accept("FOO", Integer.MAX_VALUE);
+        } catch (final Throwable e) {
+            fail("Accepting NOP must not throw an exception");
+        }
+    }
+}

src/test/java/org/apache/commons/lang3/function/FailableObjLongConsumerTest.java

@@ -0,0 +1,37 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+/**
+ * Tests {@link FailableObjLongConsumer}.
+ */
+public class FailableObjLongConsumerTest {
+    @Test
+    public void testNop() {
+        final FailableObjLongConsumer<Object, Throwable> func = FailableObjLongConsumer.nop();
+        try {
+            func.accept("FOO", Long.MAX_VALUE);
+        } catch (final Throwable e) {
+            fail("Accepting NOP must not throw an exception");
+        }
+    }
+}

src/test/java/org/apache/commons/lang3/function/FailableToDoubleBiFunctionTest.java

@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Tests {@link FailableToDoubleBiFunction}.
+ */
+public class FailableToDoubleBiFunctionTest {
+    @Test
+    public void testNop() throws Throwable {
+        final FailableToDoubleBiFunction<Object, Object, Throwable> func = FailableToDoubleBiFunction.nop();
+        assertEquals(0, func.applyAsDouble("FOO", "BAR"), "Expect NOP to return 0");
+    }
+}

src/test/java/org/apache/commons/lang3/function/FailableToDoubleFunctionTest.java

@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Tests {@link FailableToDoubleFunction}.
+ */
+public class FailableToDoubleFunctionTest {
+    @Test
+    public void testNop() throws Throwable {
+        final FailableToDoubleFunction<Object, Throwable> func = FailableToDoubleFunction.nop();
+        assertEquals(0, func.applyAsDouble("FOO"), "Expect NOP to return 0");
+    }
+}

src/test/java/org/apache/commons/lang3/function/FailableToIntBiFunctionTest.java

@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Tests {@link FailableToIntBiFunction}.
+ */
+public class FailableToIntBiFunctionTest {
+    @Test
+    public void testNop() throws Throwable {
+        final FailableToIntBiFunction<Object, Object, Throwable> func = FailableToIntBiFunction.nop();
+        assertEquals(0, func.applyAsInt("FOO", "BAR"), "Expect NOP to return 0");
+    }
+}

src/test/java/org/apache/commons/lang3/function/FailableToIntFunctionTest.java

@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Tests {@link FailableToIntFunction}.
+ */
+public class FailableToIntFunctionTest {
+    @Test
+    public void testNop() throws Throwable {
+        final FailableToIntFunction<Object, Throwable> func = FailableToIntFunction.nop();
+        assertEquals(0, func.applyAsInt("FOO"), "Expect NOP to return 0");
+    }
+}

src/test/java/org/apache/commons/lang3/function/FailableToLongBiFunctionTest.java

@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Tests {@link FailableToLongBiFunction}.
+ */
+public class FailableToLongBiFunctionTest {
+    @Test
+    public void testNop() throws Throwable {
+        final FailableToLongBiFunction<Object, Object, Throwable> func = FailableToLongBiFunction.nop();
+        assertEquals(0, func.applyAsLong("FOO", "BAR"), "Expect NOP to return 0");
+    }
+}

src/test/java/org/apache/commons/lang3/function/FailableToLongFunctionTest.java

@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Tests {@link FailableToLongFunction}.
+ */
+public class FailableToLongFunctionTest {
+    @Test
+    public void testNop() throws Throwable {
+        final FailableToLongFunction<Object, Throwable> func = FailableToLongFunction.nop();
+        assertEquals(0, func.applyAsLong("Foo"), "Expect NOP to return 0");
+    }
+}