4.x: Unit test lambdaification 3 of N (ReactiveX#8139)

* 4.x: Unit test lambdaification 3 of N

* Fix mockito crash

Author: akarnokd

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

@@ -16,7 +16,6 @@
 import static org.junit.Assert.*;
 
 import org.junit.Test;
-import static java.util.concurrent.Flow.*;
 
 import io.reactivex.rxjava4.core.ConverterTest.*;
 import io.reactivex.rxjava4.exceptions.TestException;
@@ -26,11 +25,8 @@ public class TransformerTest extends RxJavaTest {
     @Test
     public void flowableTransformerThrows() {
         try {
-            Flowable.just(1).compose(new FlowableTransformer<Integer, Integer>() {
-                @Override
-                public Publisher<Integer> apply(Flowable<Integer> v) {
-                    throw new TestException("Forced failure");
-                }
+            Flowable.just(1).compose(_ -> {
+                throw new TestException("Forced failure");
             });
             fail("Should have thrown!");
         } catch (TestException ex) {
@@ -41,11 +37,8 @@ public Publisher<Integer> apply(Flowable<Integer> v) {
     @Test
     public void observableTransformerThrows() {
         try {
-            Observable.just(1).compose(new ObservableTransformer<Integer, Integer>() {
-                @Override
-                public Observable<Integer> apply(Observable<Integer> v) {
-                    throw new TestException("Forced failure");
-                }
+            Observable.just(1).compose(_ -> {
+                throw new TestException("Forced failure");
             });
             fail("Should have thrown!");
         } catch (TestException ex) {
@@ -56,11 +49,8 @@ public Observable<Integer> apply(Observable<Integer> v) {
     @Test
     public void singleTransformerThrows() {
         try {
-            Single.just(1).compose(new SingleTransformer<Integer, Integer>() {
-                @Override
-                public Single<Integer> apply(Single<Integer> v) {
-                    throw new TestException("Forced failure");
-                }
+            Single.just(1).compose(_ -> {
+                throw new TestException("Forced failure");
             });
             fail("Should have thrown!");
         } catch (TestException ex) {
@@ -71,11 +61,8 @@ public Single<Integer> apply(Single<Integer> v) {
     @Test
     public void maybeTransformerThrows() {
         try {
-            Maybe.just(1).compose(new MaybeTransformer<Integer, Integer>() {
-                @Override
-                public Maybe<Integer> apply(Maybe<Integer> v) {
-                    throw new TestException("Forced failure");
-                }
+            Maybe.just(1).compose(_ -> {
+                throw new TestException("Forced failure");
             });
             fail("Should have thrown!");
         } catch (TestException ex) {
@@ -99,65 +86,45 @@ public void completableTransformerThrows() {
 
     @Test
     public void observableGenericsSignatureTest() {
-        A<String, Integer> a = new A<String, Integer>() { };
+        A<String, Integer> a = new A<String, Integer>() /* NFI */ { };
 
         Observable.just(a).compose(TransformerTest.<String>testObservableTransformerCreator());
     }
 
     @Test
     public void singleGenericsSignatureTest() {
-        A<String, Integer> a = new A<String, Integer>() { };
+        A<String, Integer> a = new A<String, Integer>() /* NFI */ { };
 
         Single.just(a).compose(TransformerTest.<String>testSingleTransformerCreator());
     }
 
     @Test
     public void maybeGenericsSignatureTest() {
-        A<String, Integer> a = new A<String, Integer>() { };
+        A<String, Integer> a = new A<String, Integer>() /* NFI */ { };
 
         Maybe.just(a).compose(TransformerTest.<String>testMaybeTransformerCreator());
     }
 
     @Test
     public void flowableGenericsSignatureTest() {
-        A<String, Integer> a = new A<String, Integer>() { };
+        A<String, Integer> a = new A<String, Integer>() /* NFI */ { };
 
         Flowable.just(a).compose(TransformerTest.<String>testFlowableTransformerCreator());
     }
 
     private static <T> ObservableTransformer<A<T, ?>, B<T>> testObservableTransformerCreator() {
-        return new ObservableTransformer<A<T, ?>, B<T>>() {
-            @Override
-            public ObservableSource<B<T>> apply(Observable<A<T, ?>> a) {
-                return Observable.empty();
-            }
-        };
+        return _ -> Observable.empty();
     }
 
     private static <T> SingleTransformer<A<T, ?>, B<T>> testSingleTransformerCreator() {
-        return new SingleTransformer<A<T, ?>, B<T>>() {
-            @Override
-            public SingleSource<B<T>> apply(Single<A<T, ?>> a) {
-                return Single.never();
-            }
-        };
+        return _ -> Single.never();
     }
 
     private static <T> MaybeTransformer<A<T, ?>, B<T>> testMaybeTransformerCreator() {
-        return new MaybeTransformer<A<T, ?>, B<T>>() {
-            @Override
-            public MaybeSource<B<T>> apply(Maybe<A<T, ?>> a) {
-                return Maybe.empty();
-            }
-        };
+        return _ -> Maybe.empty();
     }
 
     private static <T> FlowableTransformer<A<T, ?>, B<T>> testFlowableTransformerCreator() {
-        return new FlowableTransformer<A<T, ?>, B<T>>() {
-            @Override
-            public Publisher<B<T>> apply(Flowable<A<T, ?>> a) {
-                return Flowable.empty();
-            }
-        };
+        return _ -> Flowable.empty();
     }
 }