4.x: Unit test lambdaification 2 of N (ReactiveX#8138)

Author: akarnokd

src/test/java/io/reactivex/rxjava4/completable/CompletableRetryTest.java

@@ -21,7 +21,6 @@
 
 import io.reactivex.rxjava4.core.*;
 import io.reactivex.rxjava4.exceptions.TestException;
-import io.reactivex.rxjava4.functions.*;
 import io.reactivex.rxjava4.internal.functions.Functions;
 
 public class CompletableRetryTest extends RxJavaTest {
@@ -39,11 +38,7 @@ public void retryTimesPredicateWithMatchingPredicate() {
 
             throw new IllegalArgumentException();
         })
-        .retry(Integer.MAX_VALUE, new Predicate<Throwable>() {
-            @Override public boolean test(final Throwable throwable) throws Exception {
-                return !(throwable instanceof IllegalArgumentException);
-            }
-        })
+        .retry(Integer.MAX_VALUE, throwable -> !(throwable instanceof IllegalArgumentException))
         .test()
         .assertFailure(IllegalArgumentException.class);
 

src/test/java/io/reactivex/rxjava4/core/ConverterTest.java

@@ -25,11 +25,8 @@ public final class ConverterTest extends RxJavaTest {
     @Test
     public void flowableConverterThrows() {
         try {
-            Flowable.just(1).to(new FlowableConverter<Integer, Integer>() {
-                @Override
-                public Integer apply(Flowable<Integer> v) {
-                    throw new TestException("Forced failure");
-                }
+            Flowable.just(1).to(_ -> {
+                throw new TestException("Forced failure");
             });
             fail("Should have thrown!");
         } catch (TestException ex) {
@@ -40,11 +37,8 @@ public Integer apply(Flowable<Integer> v) {
     @Test
     public void observableConverterThrows() {
         try {
-            Observable.just(1).to(new ObservableConverter<Integer, Integer>() {
-                @Override
-                public Integer apply(Observable<Integer> v) {
-                    throw new TestException("Forced failure");
-                }
+            Observable.just(1).to(_ -> {
+                throw new TestException("Forced failure");
             });
             fail("Should have thrown!");
         } catch (TestException ex) {
@@ -55,11 +49,8 @@ public Integer apply(Observable<Integer> v) {
     @Test
     public void singleConverterThrows() {
         try {
-            Single.just(1).to(new SingleConverter<Integer, Integer>() {
-                @Override
-                public Integer apply(Single<Integer> v) {
-                    throw new TestException("Forced failure");
-                }
+            Single.just(1).to(_ -> {
+                throw new TestException("Forced failure");
             });
             fail("Should have thrown!");
         } catch (TestException ex) {
@@ -70,11 +61,8 @@ public Integer apply(Single<Integer> v) {
     @Test
     public void maybeConverterThrows() {
         try {
-            Maybe.just(1).to(new MaybeConverter<Integer, Integer>() {
-                @Override
-                public Integer apply(Maybe<Integer> v) {
-                    throw new TestException("Forced failure");
-                }
+            Maybe.just(1).to(_ -> {
+                throw new TestException("Forced failure");
             });
             fail("Should have thrown!");
         } catch (TestException ex) {
@@ -85,11 +73,8 @@ public Integer apply(Maybe<Integer> v) {
     @Test
     public void completableConverterThrows() {
         try {
-            Completable.complete().to(new CompletableConverter<Completable>() {
-                @Override
-                public Completable apply(Completable v) {
-                    throw new TestException("Forced failure");
-                }
+            Completable.complete().to(_ -> {
+                throw new TestException("Forced failure");
             });
             fail("Should have thrown!");
         } catch (TestException ex) {
@@ -102,39 +87,39 @@ public Completable apply(Completable v) {
     @SuppressWarnings({ "rawtypes", "unchecked" })
     @Test
     public void observableGenericsSignatureTest() {
-        A<String, Integer> a = new A<String, Integer>() { };
+        A<String, Integer> a = new A<String, Integer>() /* NFI */ { };
 
         Observable.just(a).to((ObservableConverter)ConverterTest.testObservableConverterCreator());
     }
 
     @SuppressWarnings({ "rawtypes", "unchecked" })
     @Test
     public void singleGenericsSignatureTest() {
-        A<String, Integer> a = new A<String, Integer>() { };
+        A<String, Integer> a = new A<String, Integer>() /* NFI */ { };
 
         Single.just(a).to((SingleConverter)ConverterTest.<String>testSingleConverterCreator());
     }
 
     @SuppressWarnings({ "rawtypes", "unchecked" })
     @Test
     public void maybeGenericsSignatureTest() {
-        A<String, Integer> a = new A<String, Integer>() { };
+        A<String, Integer> a = new A<String, Integer>() /* NFI */ { };
 
         Maybe.just(a).to((MaybeConverter)ConverterTest.<String>testMaybeConverterCreator());
     }
 
     @SuppressWarnings({ "rawtypes", "unchecked" })
     @Test
     public void flowableGenericsSignatureTest() {
-        A<String, Integer> a = new A<String, Integer>() { };
+        A<String, Integer> a = new A<String, Integer>() /* NFI */ { };
 
         Flowable.just(a).to((FlowableConverter)ConverterTest.<String>testFlowableConverterCreator());
     }
 
     @SuppressWarnings({ "rawtypes", "unchecked" })
     @Test
     public void parallelFlowableGenericsSignatureTest() {
-        A<String, Integer> a = new A<String, Integer>() { };
+        A<String, Integer> a = new A<String, Integer>() /* NFI */ { };
 
         Flowable.just(a).parallel().to((ParallelFlowableConverter)ConverterTest.<String>testParallelFlowableConverterCreator());
     }
@@ -192,7 +177,7 @@ interface B<T> { }
         return new ObservableConverter<A<T, ?>, B<T>>() {
             @Override
             public B<T> apply(Observable<A<T, ?>> a) {
-                return new B<T>() {
+                return new B<T>() /* NFI */ {
                 };
             }
         };
@@ -202,7 +187,7 @@ public B<T> apply(Observable<A<T, ?>> a) {
         return new SingleConverter<A<T, ?>, B<T>>() {
             @Override
             public B<T> apply(Single<A<T, ?>> a) {
-                return new B<T>() {
+                return new B<T>() /* NFI */ {
                 };
             }
         };
@@ -212,7 +197,7 @@ public B<T> apply(Single<A<T, ?>> a) {
         return new MaybeConverter<A<T, ?>, B<T>>() {
             @Override
             public B<T> apply(Maybe<A<T, ?>> a) {
-                return new B<T>() {
+                return new B<T>() /* NFI */ {
                 };
             }
         };
@@ -222,7 +207,7 @@ public B<T> apply(Maybe<A<T, ?>> a) {
         return new FlowableConverter<A<T, ?>, B<T>>() {
             @Override
             public B<T> apply(Flowable<A<T, ?>> a) {
-                return new B<T>() {
+                return new B<T>() /* NFI */ {
                 };
             }
         };
@@ -232,7 +217,7 @@ public B<T> apply(Flowable<A<T, ?>> a) {
         return new ParallelFlowableConverter<A<T, ?>, B<T>>() {
             @Override
             public B<T> apply(ParallelFlowable<A<T, ?>> a) {
-                return new B<T>() {
+                return new B<T>() /* NFI */ {
                 };
             }
         };