[commons-lang] branch master updated: [LANG-1568] Lambda clean ups.

[ggregory]

This is an automated email from the ASF dual-hosted git repository.

ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git


The following commit(s) were added to refs/heads/master by this push:
     new 97611fd  [LANG-1568] Lambda clean ups.
97611fd is described below

commit 97611fda5d134bc7f32533f7c11b9b2a3f4bf939
Author: Gary Gregory <garydgreg...@gmail.com>
AuthorDate: Wed Jun 24 20:28:44 2020 -0400

    [LANG-1568] Lambda clean ups.
---
 .../commons/lang3/function/FailableFunctionsTest.java    | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git 
a/src/test/java/org/apache/commons/lang3/function/FailableFunctionsTest.java 
b/src/test/java/org/apache/commons/lang3/function/FailableFunctionsTest.java
index da36ebd..3a123cf 100644
--- a/src/test/java/org/apache/commons/lang3/function/FailableFunctionsTest.java
+++ b/src/test/java/org/apache/commons/lang3/function/FailableFunctionsTest.java
@@ -675,13 +675,13 @@ public class FailableFunctionsTest {
     public void testBiFunctionAndThen() throws IOException {
         // Unchecked usage pattern in JRE
         final BiFunction<Object, Integer, Integer> nopBiFunction = (t, u) -> 
null;
-        final Function<Object, Integer> nopFunction = (t) -> null;
+        final Function<Object, Integer> nopFunction = t -> null;
         nopBiFunction.andThen(nopFunction);
         // Checked usage pattern
         final FailableBiFunction<Object, Integer, Integer, IOException> 
failingBiFunctionTest = (t, u) -> {
             throw new IOException();
         };
-        final FailableFunction<Object, Integer, IOException> failingFunction = 
(t) -> { throw new IOException(); };
+        final FailableFunction<Object, Integer, IOException> failingFunction = 
t -> { throw new IOException(); };
         final FailableBiFunction<Object, Integer, Integer, IOException> 
nopFailableBiFunction = FailableBiFunction
             .nop();
         final FailableFunction<Object, Integer, IOException> 
nopFailableFunction = FailableFunction.nop();
@@ -735,7 +735,7 @@ public class FailableFunctionsTest {
     @Test
     public void testConsumerAndThen() throws Throwable {
         final Testable<?, ?> testable = new Testable<>(null);
-        final FailableConsumer<Throwable, Throwable> failableConsumer = (th) 
-> {
+        final FailableConsumer<Throwable, Throwable> failableConsumer = th -> {
             testable.setThrowable(th);
             testable.test();
         };
@@ -769,7 +769,7 @@ public class FailableFunctionsTest {
     @Test
     public void testDoublePredicate() throws Throwable {
         FailureOnOddInvocations.invocations = 0;
-        final FailableDoublePredicate<Throwable> failablePredicate = t1 -> 
FailureOnOddInvocations.testDouble(t1);
+        final FailableDoublePredicate<Throwable> failablePredicate = 
FailureOnOddInvocations::testDouble;
         assertThrows(SomeException.class, () -> failablePredicate.test(1d));
         failablePredicate.test(1d);
     }
@@ -802,10 +802,10 @@ public class FailableFunctionsTest {
     @Test
     public void testFunctionAndThen() throws IOException {
         // Unchecked usage pattern in JRE
-        final Function<Object, Integer> nopFunction = (t) -> null;
+        final Function<Object, Integer> nopFunction = t -> null;
         nopFunction.andThen(nopFunction);
         // Checked usage pattern
-        final FailableFunction<Object, Integer, IOException> failingFunction = 
(t) -> { throw new IOException(); };
+        final FailableFunction<Object, Integer, IOException> failingFunction = 
t -> { throw new IOException(); };
         final FailableFunction<Object, Integer, IOException> 
nopFailableFunction = FailableFunction.nop();
         //
         assertThrows(IOException.class, () -> 
failingFunction.andThen(failingFunction).apply(null));
@@ -963,7 +963,7 @@ public class FailableFunctionsTest {
     @Test
     public void testIntPredicate() throws Throwable {
         FailureOnOddInvocations.invocations = 0;
-        final FailableIntPredicate<Throwable> failablePredicate = t1 -> 
FailureOnOddInvocations.testInt(t1);
+        final FailableIntPredicate<Throwable> failablePredicate = 
FailureOnOddInvocations::testInt;
         assertThrows(SomeException.class, () -> failablePredicate.test(1));
         failablePredicate.test(1);
     }
@@ -989,7 +989,7 @@ public class FailableFunctionsTest {
     @Test
     public void testLongPredicate() throws Throwable {
         FailureOnOddInvocations.invocations = 0;
-        final FailableLongPredicate<Throwable> failablePredicate = t1 -> 
FailureOnOddInvocations.testLong(t1);
+        final FailableLongPredicate<Throwable> failablePredicate = 
FailureOnOddInvocations::testLong;
         assertThrows(SomeException.class, () -> failablePredicate.test(1L));
         failablePredicate.test(1L);
     }