From e6cef1305184acfad0ce493031addf0b174027e6 Mon Sep 17 00:00:00 2001
From: Puneet Dixit <236133619+puneetdixit200@users.noreply.github.com>
Date: Fri, 22 May 2026 23:09:54 +0530
Subject: [PATCH] test: simplify SingleRetryTest callables

---
 .../rxjava4/single/SingleRetryTest.java       | 64 ++++++++-----------
 1 file changed, 25 insertions(+), 39 deletions(-)

diff --git a/src/test/java/io/reactivex/rxjava4/single/SingleRetryTest.java b/src/test/java/io/reactivex/rxjava4/single/SingleRetryTest.java
index 1c86e6a3da..d682e7d1f7 100644
--- a/src/test/java/io/reactivex/rxjava4/single/SingleRetryTest.java
+++ b/src/test/java/io/reactivex/rxjava4/single/SingleRetryTest.java
@@ -15,14 +15,12 @@
 
 import static org.junit.Assert.assertEquals;
 
-import java.util.concurrent.Callable;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Test;
 
 import io.reactivex.rxjava4.core.*;
 import io.reactivex.rxjava4.exceptions.TestException;
-import io.reactivex.rxjava4.functions.Predicate;
 import io.reactivex.rxjava4.internal.functions.Functions;
 
 public class SingleRetryTest extends RxJavaTest {
@@ -31,22 +29,16 @@ public void retryTimesPredicateWithMatchingPredicate() {
         final AtomicInteger atomicInteger = new AtomicInteger(3);
         final AtomicInteger numberOfSubscribeCalls = new AtomicInteger(0);
 
-        Single.fromCallable(new Callable<Boolean>() {
-            @Override public Boolean call() throws Exception {
-                numberOfSubscribeCalls.incrementAndGet();
+        Single.fromCallable(() -> {
+            numberOfSubscribeCalls.incrementAndGet();
 
-                if (atomicInteger.decrementAndGet() != 0) {
-                    throw new RuntimeException();
-                }
-
-                throw new IllegalArgumentException();
+            if (atomicInteger.decrementAndGet() != 0) {
+                throw new RuntimeException();
             }
+
+            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);
 
@@ -58,16 +50,14 @@ public void retryTimesPredicateWithMatchingRetryAmount() {
         final AtomicInteger atomicInteger = new AtomicInteger(3);
         final AtomicInteger numberOfSubscribeCalls = new AtomicInteger(0);
 
-        Single.fromCallable(new Callable<Boolean>() {
-            @Override public Boolean call() throws Exception {
-                numberOfSubscribeCalls.incrementAndGet();
+        Single.fromCallable(() -> {
+            numberOfSubscribeCalls.incrementAndGet();
 
-                if (atomicInteger.decrementAndGet() != 0) {
-                    throw new RuntimeException();
-                }
-
-                return true;
+            if (atomicInteger.decrementAndGet() != 0) {
+                throw new RuntimeException();
             }
+
+            return true;
         })
             .retry(2, Functions.alwaysTrue())
             .test()
@@ -81,16 +71,14 @@ public void retryTimesPredicateWithNotMatchingRetryAmount() {
         final AtomicInteger atomicInteger = new AtomicInteger(3);
         final AtomicInteger numberOfSubscribeCalls = new AtomicInteger(0);
 
-        Single.fromCallable(new Callable<Boolean>() {
-            @Override public Boolean call() throws Exception {
-                numberOfSubscribeCalls.incrementAndGet();
+        Single.fromCallable(() -> {
+            numberOfSubscribeCalls.incrementAndGet();
 
-                if (atomicInteger.decrementAndGet() != 0) {
-                    throw new RuntimeException();
-                }
-
-                return true;
+            if (atomicInteger.decrementAndGet() != 0) {
+                throw new RuntimeException();
             }
+
+            return true;
         })
             .retry(1, Functions.alwaysTrue())
             .test()
@@ -104,16 +92,14 @@ public void retryTimesPredicateWithZeroRetries() {
         final AtomicInteger atomicInteger = new AtomicInteger(2);
         final AtomicInteger numberOfSubscribeCalls = new AtomicInteger(0);
 
-        Single.fromCallable(new Callable<Boolean>() {
-            @Override public Boolean call() throws Exception {
-                numberOfSubscribeCalls.incrementAndGet();
+        Single.fromCallable(() -> {
+            numberOfSubscribeCalls.incrementAndGet();
 
-                if (atomicInteger.decrementAndGet() != 0) {
-                    throw new RuntimeException();
-                }
-
-                return true;
+            if (atomicInteger.decrementAndGet() != 0) {
+                throw new RuntimeException();
             }
+
+            return true;
         })
             .retry(0, Functions.alwaysTrue())
             .test()