{"evidenceTier":"self-signed","executor":{"implName":"manual-demand-test","implVersion":"1","mode":"manual","model":"claude-sonnet-5 (solve), reviewed"},"generatedAt":"2026-07-29T09:45:51.272Z","participant":{"agentEoa":"0x654862876C8Ddaa048Fa9E0D32D5e0e81bD4Bd20"},"payload":{"branch":"isolate-race-tests-flowable-flatmap-mergewith","commitSha":"13f4cfb90433c493072698c90dd354d7d8a76839","patchDiff":"diff --git a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapIsolatedTest.java b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapIsolatedTest.java\nnew file mode 100644\nindex 0000000..a4f90fa\n--- /dev/null\n+++ b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapIsolatedTest.java\n@@ -0,0 +1,100 @@\n+/*\n+ * Copyright (c) 2016-present, RxJava Contributors.\n+ *\n+ * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in\n+ * compliance with the License. You may obtain a copy of the License at\n+ *\n+ * http://www.apache.org/licenses/LICENSE-2.0\n+ *\n+ * Unless required by applicable law or agreed to in writing, software distributed under the License is\n+ * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See\n+ * the License for the specific language governing permissions and limitations under the License.\n+ */\n+\n+package io.reactivex.rxjava4.internal.operators.flowable;\n+\n+import static org.junit.jupiter.api.Assertions.assertTrue;\n+\n+import java.util.List;\n+\n+import org.junit.jupiter.api.Test;\n+import org.junit.jupiter.api.parallel.Isolated;\n+\n+import io.reactivex.rxjava4.core.Flowable;\n+import io.reactivex.rxjava4.core.RxJavaTest;\n+import io.reactivex.rxjava4.internal.functions.Functions;\n+import io.reactivex.rxjava4.plugins.RxJavaPlugins;\n+import io.reactivex.rxjava4.processors.PublishProcessor;\n+import io.reactivex.rxjava4.subscribers.TestSubscriber;\n+import io.reactivex.rxjava4.testsupport.TestHelper;\n+\n+@Isolated\n+public class FlowableFlatMapIsolatedTest extends RxJavaTest {\n+\n+    @Test\n+    public void innerCompleteCancelRace() {\n+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {\n+            final PublishProcessor<Integer> pp = PublishProcessor.create();\n+\n+            final TestSubscriber<Integer> ts = Flowable.merge(Flowable.just(pp)).test();\n+\n+            Runnable r1 = pp::onComplete;\n+\n+            Runnable r2 = ts::cancel;\n+\n+            TestHelper.race(r1, r2);\n+        }\n+    }\n+\n+    @Test\n+    public void cancelScalarDrainRace() {\n+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {\n+            List<Throwable> errors = TestHelper.trackPluginErrors();\n+            try {\n+\n+                final PublishProcessor<Flowable<Integer>> pp = PublishProcessor.create();\n+\n+                final TestSubscriber<Integer> ts = pp.flatMap(Functions.<Flowable<Integer>>identity()).test(0);\n+\n+                Runnable r1 = ts::cancel;\n+                Runnable r2 = pp::onComplete;\n+\n+                TestHelper.race(r1, r2);\n+\n+                assertTrue(errors.isEmpty(), errors.toString());\n+            } finally {\n+                RxJavaPlugins.reset();\n+            }\n+        }\n+    }\n+\n+    @Test\n+    public void cancelDrainRace() {\n+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {\n+            for (int j = 1; j < 50; j += 5) {\n+                List<Throwable> errors = TestHelper.trackPluginErrors();\n+                try {\n+\n+                    final PublishProcessor<Flowable<Integer>> pp = PublishProcessor.create();\n+\n+                    final TestSubscriber<Integer> ts = pp.flatMap(Functions.<Flowable<Integer>>identity()).test(0);\n+\n+                    final PublishProcessor<Integer> just = PublishProcessor.create();\n+                    pp.onNext(just);\n+\n+                    Runnable r1 = () -> {\n+                        ts.request(1);\n+                        ts.cancel();\n+                    };\n+                    Runnable r2 = () -> just.onNext(1);\n+\n+                    TestHelper.race(r1, r2);\n+\n+                    assertTrue(errors.isEmpty(), errors.toString());\n+                } finally {\n+                    RxJavaPlugins.reset();\n+                }\n+            }\n+        }\n+    }\n+}\ndiff --git a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapMaybeIsolatedTest.java b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapMaybeIsolatedTest.java\nnew file mode 100644\nindex 0000000..6cf4bbb\n--- /dev/null\n+++ b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapMaybeIsolatedTest.java\n@@ -0,0 +1,78 @@\n+/*\n+ * Copyright (c) 2016-present, RxJava Contributors.\n+ *\n+ * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in\n+ * compliance with the License. You may obtain a copy of the License at\n+ *\n+ * http://www.apache.org/licenses/LICENSE-2.0\n+ *\n+ * Unless required by applicable law or agreed to in writing, software distributed under the License is\n+ * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See\n+ * the License for the specific language governing permissions and limitations under the License.\n+ */\n+\n+package io.reactivex.rxjava4.internal.operators.flowable;\n+\n+import org.junit.jupiter.api.Test;\n+import org.junit.jupiter.api.parallel.Isolated;\n+\n+import io.reactivex.rxjava4.core.Flowable;\n+import io.reactivex.rxjava4.core.Maybe;\n+import io.reactivex.rxjava4.core.RxJavaTest;\n+import io.reactivex.rxjava4.internal.functions.Functions;\n+import io.reactivex.rxjava4.subjects.MaybeSubject;\n+import io.reactivex.rxjava4.subscribers.TestSubscriber;\n+import io.reactivex.rxjava4.testsupport.TestHelper;\n+\n+@Isolated\n+public class FlowableFlatMapMaybeIsolatedTest extends RxJavaTest {\n+\n+    @Test\n+    public void requestCancelRace() {\n+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {\n+            final TestSubscriber<Integer> ts = Flowable.just(1).concatWith(Flowable.<Integer>never())\n+            .flatMapMaybe(Functions.justFunction(Maybe.just(2))).test(0);\n+\n+            Runnable r1 = () -> ts.request(1);\n+            Runnable r2 = ts::cancel;\n+\n+            TestHelper.race(r1, r2);\n+        }\n+    }\n+\n+    @Test\n+    public void successRace() {\n+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {\n+            MaybeSubject<Integer> ms1 = MaybeSubject.create();\n+            MaybeSubject<Integer> ms2 = MaybeSubject.create();\n+\n+            TestSubscriber<Integer> ts = Flowable.just(ms1, ms2).flatMapMaybe(v -> v)\n+            .test();\n+\n+            TestHelper.race(\n+                    () -> ms1.onSuccess(1),\n+                    () -> ms2.onSuccess(1)\n+            );\n+\n+            ts.assertResult(1, 1);\n+        }\n+    }\n+\n+    @Test\n+    public void successCompleteRace() {\n+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {\n+            MaybeSubject<Integer> ms1 = MaybeSubject.create();\n+            MaybeSubject<Integer> ms2 = MaybeSubject.create();\n+\n+            TestSubscriber<Integer> ts = Flowable.just(ms1, ms2).flatMapMaybe(v -> v)\n+            .test();\n+\n+            TestHelper.race(\n+                    () -> ms1.onSuccess(1),\n+                    ms2::onComplete\n+            );\n+\n+            ts.assertResult(1);\n+        }\n+    }\n+}\ndiff --git a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapMaybeTest.java b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapMaybeTest.java\nindex ca83f72..0dc4558 100644\n--- a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapMaybeTest.java\n+++ b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapMaybeTest.java\n@@ -471,19 +471,6 @@ public class FlowableFlatMapMaybeTest extends RxJavaTest {\n         .assertFailure(TestException.class);\n     }\n \n-    @Test\n-    public void requestCancelRace() {\n-        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {\n-            final TestSubscriber<Integer> ts = Flowable.just(1).concatWith(Flowable.<Integer>never())\n-            .flatMapMaybe(Functions.justFunction(Maybe.just(2))).test(0);\n-\n-            Runnable r1 = () -> ts.request(1);\n-            Runnable r2 = ts::cancel;\n-\n-            TestHelper.race(r1, r2);\n-        }\n-    }\n-\n     @Test\n     public void undeliverableUponCancel() {\n         TestHelper.checkUndeliverableUponCancel((FlowableConverter<Integer, Flowable<Integer>>) upstream ->\n@@ -502,42 +489,6 @@ public class FlowableFlatMapMaybeTest extends RxJavaTest {\n         TestHelper.assertBadRequestReported(Flowable.never().flatMapMaybe(_ -> Maybe.never()));\n     }\n \n-    @Test\n-    public void successRace() {\n-        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {\n-            MaybeSubject<Integer> ms1 = MaybeSubject.create();\n-            MaybeSubject<Integer> ms2 = MaybeSubject.create();\n-\n-            TestSubscriber<Integer> ts = Flowable.just(ms1, ms2).flatMapMaybe(v -> v)\n-            .test();\n-\n-            TestHelper.race(\n-                    () -> ms1.onSuccess(1),\n-                    () -> ms2.onSuccess(1)\n-            );\n-\n-            ts.assertResult(1, 1);\n-        }\n-    }\n-\n-    @Test\n-    public void successCompleteRace() {\n-        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {\n-            MaybeSubject<Integer> ms1 = MaybeSubject.create();\n-            MaybeSubject<Integer> ms2 = MaybeSubject.create();\n-\n-            TestSubscriber<Integer> ts = Flowable.just(ms1, ms2).flatMapMaybe(v -> v)\n-            .test();\n-\n-            TestHelper.race(\n-                    () -> ms1.onSuccess(1),\n-                    ms2::onComplete\n-            );\n-\n-            ts.assertResult(1);\n-        }\n-    }\n-\n     @Test\n     public void successShortcut() {\n         MaybeSubject<Integer> ms1 = MaybeSubject.create();\ndiff --git a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapSingleIsolatedTest.java b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapSingleIsolatedTest.java\nnew file mode 100644\nindex 0000000..1c6fe78\n--- /dev/null\n+++ b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapSingleIsolatedTest.java\n@@ -0,0 +1,60 @@\n+/*\n+ * Copyright (c) 2016-present, RxJava Contributors.\n+ *\n+ * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in\n+ * compliance with the License. You may obtain a copy of the License at\n+ *\n+ * http://www.apache.org/licenses/LICENSE-2.0\n+ *\n+ * Unless required by applicable law or agreed to in writing, software distributed under the License is\n+ * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See\n+ * the License for the specific language governing permissions and limitations under the License.\n+ */\n+\n+package io.reactivex.rxjava4.internal.operators.flowable;\n+\n+import org.junit.jupiter.api.Test;\n+import org.junit.jupiter.api.parallel.Isolated;\n+\n+import io.reactivex.rxjava4.core.Flowable;\n+import io.reactivex.rxjava4.core.RxJavaTest;\n+import io.reactivex.rxjava4.core.Single;\n+import io.reactivex.rxjava4.internal.functions.Functions;\n+import io.reactivex.rxjava4.subjects.SingleSubject;\n+import io.reactivex.rxjava4.subscribers.TestSubscriber;\n+import io.reactivex.rxjava4.testsupport.TestHelper;\n+\n+@Isolated\n+public class FlowableFlatMapSingleIsolatedTest extends RxJavaTest {\n+\n+    @Test\n+    public void requestCancelRace() {\n+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {\n+            final TestSubscriber<Integer> ts = Flowable.just(1).concatWith(Flowable.<Integer>never())\n+            .flatMapSingle(Functions.justFunction(Single.just(2))).test(0);\n+\n+            Runnable r1 = () -> ts.request(1);\n+            Runnable r2 = ts::cancel;\n+\n+            TestHelper.race(r1, r2);\n+        }\n+    }\n+\n+    @Test\n+    public void successRace() {\n+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {\n+            SingleSubject<Integer> ss1 = SingleSubject.create();\n+            SingleSubject<Integer> ss2 = SingleSubject.create();\n+\n+            TestSubscriber<Integer> ts = Flowable.just(ss1, ss2).flatMapSingle(v -> v)\n+            .test();\n+\n+            TestHelper.race(\n+                    () -> ss1.onSuccess(1),\n+                    () -> ss2.onSuccess(1)\n+            );\n+\n+            ts.assertResult(1, 1);\n+        }\n+    }\n+}\ndiff --git a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapSingleTest.java b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapSingleTest.java\nindex 9d6b443..fffeb29 100644\n--- a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapSingleTest.java\n+++ b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapSingleTest.java\n@@ -382,19 +382,6 @@ public class FlowableFlatMapSingleTest extends RxJavaTest {\n         .assertFailure(TestException.class);\n     }\n \n-    @Test\n-    public void requestCancelRace() {\n-        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {\n-            final TestSubscriber<Integer> ts = Flowable.just(1).concatWith(Flowable.<Integer>never())\n-            .flatMapSingle(Functions.justFunction(Single.just(2))).test(0);\n-\n-            Runnable r1 = () -> ts.request(1);\n-            Runnable r2 = ts::cancel;\n-\n-            TestHelper.race(r1, r2);\n-        }\n-    }\n-\n     @Test\n     public void asyncFlattenErrorMaxConcurrency() {\n         Flowable.range(1, 1000)\n@@ -425,24 +412,6 @@ public class FlowableFlatMapSingleTest extends RxJavaTest {\n         TestHelper.assertBadRequestReported(Flowable.never().flatMapSingle(_ -> Single.never()));\n     }\n \n-    @Test\n-    public void successRace() {\n-        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {\n-            SingleSubject<Integer> ss1 = SingleSubject.create();\n-            SingleSubject<Integer> ss2 = SingleSubject.create();\n-\n-            TestSubscriber<Integer> ts = Flowable.just(ss1, ss2).flatMapSingle(v -> v)\n-            .test();\n-\n-            TestHelper.race(\n-                    () -> ss1.onSuccess(1),\n-                    () -> ss2.onSuccess(1)\n-            );\n-\n-            ts.assertResult(1, 1);\n-        }\n-    }\n-\n     @Test\n     public void successShortcut() {\n         SingleSubject<Integer> ss1 = SingleSubject.create();\ndiff --git a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapTest.java b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapTest.java\nindex af0ba9b..3ec265c 100644\n--- a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapTest.java\n+++ b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableFlatMapTest.java\n@@ -648,21 +648,6 @@ public class FlowableFlatMapTest extends RxJavaTest {\n         ts.assertResult(1, 2);\n     }\n \n-    @Test\n-    public void innerCompleteCancelRace() {\n-        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {\n-            final PublishProcessor<Integer> pp = PublishProcessor.create();\n-\n-            final TestSubscriber<Integer> ts = Flowable.merge(Flowable.just(pp)).test();\n-\n-            Runnable r1 = pp::onComplete;\n-\n-            Runnable r2 = ts::cancel;\n-\n-            TestHelper.race(r1, r2);\n-        }\n-    }\n-\n     @Test\n     public void fusedInnerThrows() {\n         Flowable.just(1).hide()\n@@ -715,58 +700,6 @@ public class FlowableFlatMapTest extends RxJavaTest {\n         }\n     }\n \n-    @Test\n-    public void cancelScalarDrainRace() {\n-        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {\n-            List<Throwable> errors = TestHelper.trackPluginErrors();\n-            try {\n-\n-                final PublishProcessor<Flowable<Integer>> pp = PublishProcessor.create();\n-\n-                final TestSubscriber<Integer> ts = pp.flatMap(Functions.<Flowable<Integer>>identity()).test(0);\n-\n-                Runnable r1 = ts::cancel;\n-                Runnable r2 = pp::onComplete;\n-\n-                TestHelper.race(r1, r2);\n-\n-                assertTrue(errors.isEmpty(), errors.toString());\n-            } finally {\n-                RxJavaPlugins.reset();\n-            }\n-        }\n-    }\n-\n-    @Test\n-    public void cancelDrainRace() {\n-        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {\n-            for (int j = 1; j < 50; j += 5) {\n-                List<Throwable> errors = TestHelper.trackPluginErrors();\n-                try {\n-\n-                    final PublishProcessor<Flowable<Integer>> pp = PublishProcessor.create();\n-\n-                    final TestSubscriber<Integer> ts = pp.flatMap(Functions.<Flowable<Integer>>identity()).test(0);\n-\n-                    final PublishProcessor<Integer> just = PublishProcessor.create();\n-                    pp.onNext(just);\n-\n-                    Runnable r1 = () -> {\n-                        ts.request(1);\n-                        ts.cancel();\n-                    };\n-                    Runnable r2 = () -> just.onNext(1);\n-\n-                    TestHelper.race(r1, r2);\n-\n-                    assertTrue(errors.isEmpty(), errors.toString());\n-                } finally {\n-                    RxJavaPlugins.reset();\n-                }\n-            }\n-        }\n-    }\n-\n     @Test\n     public void iterableMapperFunctionReturnsNull() {\n         Flowable.just(1)\ndiff --git a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithCompletableIsolatedTest.java b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithCompletableIsolatedTest.java\nnew file mode 100644\nindex 0000000..8592955\n--- /dev/null\n+++ b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithCompletableIsolatedTest.java\n@@ -0,0 +1,48 @@\n+/*\n+ * Copyright (c) 2016-present, RxJava Contributors.\n+ *\n+ * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in\n+ * compliance with the License. You may obtain a copy of the License at\n+ *\n+ * http://www.apache.org/licenses/LICENSE-2.0\n+ *\n+ * Unless required by applicable law or agreed to in writing, software distributed under the License is\n+ * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See\n+ * the License for the specific language governing permissions and limitations under the License.\n+ */\n+\n+package io.reactivex.rxjava4.internal.operators.flowable;\n+\n+import org.junit.jupiter.api.Test;\n+import org.junit.jupiter.api.parallel.Isolated;\n+\n+import io.reactivex.rxjava4.core.RxJavaTest;\n+import io.reactivex.rxjava4.processors.PublishProcessor;\n+import io.reactivex.rxjava4.subjects.CompletableSubject;\n+import io.reactivex.rxjava4.subscribers.TestSubscriber;\n+import io.reactivex.rxjava4.testsupport.TestHelper;\n+\n+@Isolated\n+public class FlowableMergeWithCompletableIsolatedTest extends RxJavaTest {\n+\n+    @Test\n+    public void completeRace() {\n+        for (int i = 0; i < 1000; i++) {\n+            final PublishProcessor<Integer> pp = PublishProcessor.create();\n+            final CompletableSubject cs = CompletableSubject.create();\n+\n+            TestSubscriber<Integer> ts = pp.mergeWith(cs).test();\n+\n+            Runnable r1 = () -> {\n+                pp.onNext(1);\n+                pp.onComplete();\n+            };\n+\n+            Runnable r2 = cs::onComplete;\n+\n+            TestHelper.race(r1, r2);\n+\n+            ts.assertResult(1);\n+        }\n+    }\n+}\ndiff --git a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithCompletableTest.java b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithCompletableTest.java\nindex d0f9b45..2f7038c 100644\n--- a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithCompletableTest.java\n+++ b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithCompletableTest.java\n@@ -98,27 +98,6 @@ public class FlowableMergeWithCompletableTest extends RxJavaTest {\n         .assertFailure(TestException.class);\n     }\n \n-    @Test\n-    public void completeRace() {\n-        for (int i = 0; i < 1000; i++) {\n-            final PublishProcessor<Integer> pp = PublishProcessor.create();\n-            final CompletableSubject cs = CompletableSubject.create();\n-\n-            TestSubscriber<Integer> ts = pp.mergeWith(cs).test();\n-\n-            Runnable r1 = () -> {\n-                pp.onNext(1);\n-                pp.onComplete();\n-            };\n-\n-            Runnable r2 = cs::onComplete;\n-\n-            TestHelper.race(r1, r2);\n-\n-            ts.assertResult(1);\n-        }\n-    }\n-\n     @Test\n     public void cancelOtherOnMainError() {\n         PublishProcessor<Integer> pp = PublishProcessor.create();\ndiff --git a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithMaybeIsolatedTest.java b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithMaybeIsolatedTest.java\nnew file mode 100644\nindex 0000000..e56d7cc\n--- /dev/null\n+++ b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithMaybeIsolatedTest.java\n@@ -0,0 +1,92 @@\n+/*\n+ * Copyright (c) 2016-present, RxJava Contributors.\n+ *\n+ * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in\n+ * compliance with the License. You may obtain a copy of the License at\n+ *\n+ * http://www.apache.org/licenses/LICENSE-2.0\n+ *\n+ * Unless required by applicable law or agreed to in writing, software distributed under the License is\n+ * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See\n+ * the License for the specific language governing permissions and limitations under the License.\n+ */\n+\n+package io.reactivex.rxjava4.internal.operators.flowable;\n+\n+import org.junit.jupiter.api.Test;\n+import org.junit.jupiter.api.parallel.Isolated;\n+\n+import io.reactivex.rxjava4.core.RxJavaTest;\n+import io.reactivex.rxjava4.processors.PublishProcessor;\n+import io.reactivex.rxjava4.subjects.MaybeSubject;\n+import io.reactivex.rxjava4.subscribers.TestSubscriber;\n+import io.reactivex.rxjava4.testsupport.TestHelper;\n+\n+@Isolated\n+public class FlowableMergeWithMaybeIsolatedTest extends RxJavaTest {\n+\n+    @Test\n+    public void completeRace() {\n+        for (int i = 0; i < 10000; i++) {\n+            final PublishProcessor<Integer> pp = PublishProcessor.create();\n+            final MaybeSubject<Integer> cs = MaybeSubject.create();\n+\n+            TestSubscriber<Integer> ts = pp.mergeWith(cs).test();\n+\n+            Runnable r1 = () -> {\n+                pp.onNext(1);\n+                pp.onComplete();\n+            };\n+\n+            Runnable r2 = () -> cs.onSuccess(1);\n+\n+            TestHelper.race(r1, r2);\n+\n+            ts.assertResult(1, 1);\n+        }\n+    }\n+\n+    @Test\n+    public void onSuccessFastPathBackpressuredRace() {\n+        for (int i = 0; i < 10000; i++) {\n+            final PublishProcessor<Integer> pp = PublishProcessor.create();\n+            final MaybeSubject<Integer> cs = MaybeSubject.create();\n+\n+            final TestSubscriber<Integer> ts = pp.mergeWith(cs).subscribeWith(new TestSubscriber<>(0));\n+\n+            Runnable r1 = () -> cs.onSuccess(1);\n+\n+            Runnable r2 = () -> ts.request(2);\n+\n+            TestHelper.race(r1, r2);\n+\n+            pp.onNext(2);\n+            pp.onComplete();\n+\n+            ts.assertResult(1, 2);\n+        }\n+    }\n+\n+    @Test\n+    public void onNextRequestRace() {\n+        for (int i = 0; i < 10000; i++) {\n+            final PublishProcessor<Integer> pp = PublishProcessor.create();\n+            final MaybeSubject<Integer> cs = MaybeSubject.create();\n+\n+            final TestSubscriber<Integer> ts = pp.mergeWith(cs).test(0);\n+\n+            pp.onNext(0);\n+\n+            Runnable r1 = () -> pp.onNext(1);\n+\n+            Runnable r2 = () -> ts.request(3);\n+\n+            TestHelper.race(r1, r2);\n+\n+            cs.onSuccess(1);\n+            pp.onComplete();\n+\n+            ts.assertResult(0, 1, 1);\n+        }\n+    }\n+}\ndiff --git a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithMaybeTest.java b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithMaybeTest.java\nindex aa29285..53d4333 100644\n--- a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithMaybeTest.java\n+++ b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithMaybeTest.java\n@@ -123,27 +123,6 @@ public class FlowableMergeWithMaybeTest extends RxJavaTest {\n         .assertFailure(TestException.class);\n     }\n \n-    @Test\n-    public void completeRace() {\n-        for (int i = 0; i < 10000; i++) {\n-            final PublishProcessor<Integer> pp = PublishProcessor.create();\n-            final MaybeSubject<Integer> cs = MaybeSubject.create();\n-\n-            TestSubscriber<Integer> ts = pp.mergeWith(cs).test();\n-\n-            Runnable r1 = () -> {\n-                pp.onNext(1);\n-                pp.onComplete();\n-            };\n-\n-            Runnable r2 = () -> cs.onSuccess(1);\n-\n-            TestHelper.race(r1, r2);\n-\n-            ts.assertResult(1, 1);\n-        }\n-    }\n-\n     @Test\n     public void onNextSlowPath() {\n         final PublishProcessor<Integer> pp = PublishProcessor.create();\n@@ -215,27 +194,6 @@ public class FlowableMergeWithMaybeTest extends RxJavaTest {\n         ts.assertResult(1, 2, 3);\n     }\n \n-    @Test\n-    public void onSuccessFastPathBackpressuredRace() {\n-        for (int i = 0; i < 10000; i++) {\n-            final PublishProcessor<Integer> pp = PublishProcessor.create();\n-            final MaybeSubject<Integer> cs = MaybeSubject.create();\n-\n-            final TestSubscriber<Integer> ts = pp.mergeWith(cs).subscribeWith(new TestSubscriber<>(0));\n-\n-            Runnable r1 = () -> cs.onSuccess(1);\n-\n-            Runnable r2 = () -> ts.request(2);\n-\n-            TestHelper.race(r1, r2);\n-\n-            pp.onNext(2);\n-            pp.onComplete();\n-\n-            ts.assertResult(1, 2);\n-        }\n-    }\n-\n     @Test\n     public void onErrorMainOverflow() {\n         List<Throwable> errors = TestHelper.trackPluginErrors();\n@@ -278,29 +236,6 @@ public class FlowableMergeWithMaybeTest extends RxJavaTest {\n         }\n     }\n \n-    @Test\n-    public void onNextRequestRace() {\n-        for (int i = 0; i < 10000; i++) {\n-            final PublishProcessor<Integer> pp = PublishProcessor.create();\n-            final MaybeSubject<Integer> cs = MaybeSubject.create();\n-\n-            final TestSubscriber<Integer> ts = pp.mergeWith(cs).test(0);\n-\n-            pp.onNext(0);\n-\n-            Runnable r1 = () -> pp.onNext(1);\n-\n-            Runnable r2 = () -> ts.request(3);\n-\n-            TestHelper.race(r1, r2);\n-\n-            cs.onSuccess(1);\n-            pp.onComplete();\n-\n-            ts.assertResult(0, 1, 1);\n-        }\n-    }\n-\n     @Test\n     public void doubleOnSubscribeMain() {\n         TestHelper.checkDoubleOnSubscribeFlowable(\ndiff --git a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithSingleIsolatedTest.java b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithSingleIsolatedTest.java\nnew file mode 100644\nindex 0000000..7859f7a\n--- /dev/null\n+++ b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithSingleIsolatedTest.java\n@@ -0,0 +1,92 @@\n+/*\n+ * Copyright (c) 2016-present, RxJava Contributors.\n+ *\n+ * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in\n+ * compliance with the License. You may obtain a copy of the License at\n+ *\n+ * http://www.apache.org/licenses/LICENSE-2.0\n+ *\n+ * Unless required by applicable law or agreed to in writing, software distributed under the License is\n+ * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See\n+ * the License for the specific language governing permissions and limitations under the License.\n+ */\n+\n+package io.reactivex.rxjava4.internal.operators.flowable;\n+\n+import org.junit.jupiter.api.Test;\n+import org.junit.jupiter.api.parallel.Isolated;\n+\n+import io.reactivex.rxjava4.core.RxJavaTest;\n+import io.reactivex.rxjava4.processors.PublishProcessor;\n+import io.reactivex.rxjava4.subjects.SingleSubject;\n+import io.reactivex.rxjava4.subscribers.TestSubscriber;\n+import io.reactivex.rxjava4.testsupport.TestHelper;\n+\n+@Isolated\n+public class FlowableMergeWithSingleIsolatedTest extends RxJavaTest {\n+\n+    @Test\n+    public void completeRace() {\n+        for (int i = 0; i < 10000; i++) {\n+            final PublishProcessor<Integer> pp = PublishProcessor.create();\n+            final SingleSubject<Integer> cs = SingleSubject.create();\n+\n+            TestSubscriber<Integer> ts = pp.mergeWith(cs).test();\n+\n+            Runnable r1 = () -> {\n+                pp.onNext(1);\n+                pp.onComplete();\n+            };\n+\n+            Runnable r2 = () -> cs.onSuccess(1);\n+\n+            TestHelper.race(r1, r2);\n+\n+            ts.assertResult(1, 1);\n+        }\n+    }\n+\n+    @Test\n+    public void onSuccessFastPathBackpressuredRace() {\n+        for (int i = 0; i < 10000; i++) {\n+            final PublishProcessor<Integer> pp = PublishProcessor.create();\n+            final SingleSubject<Integer> cs = SingleSubject.create();\n+\n+            final TestSubscriber<Integer> ts = pp.mergeWith(cs).subscribeWith(new TestSubscriber<>(0));\n+\n+            Runnable r1 = () -> cs.onSuccess(1);\n+\n+            Runnable r2 = () -> ts.request(2);\n+\n+            TestHelper.race(r1, r2);\n+\n+            pp.onNext(2);\n+            pp.onComplete();\n+\n+            ts.assertResult(1, 2);\n+        }\n+    }\n+\n+    @Test\n+    public void onNextRequestRace() {\n+        for (int i = 0; i < 10000; i++) {\n+            final PublishProcessor<Integer> pp = PublishProcessor.create();\n+            final SingleSubject<Integer> cs = SingleSubject.create();\n+\n+            final TestSubscriber<Integer> ts = pp.mergeWith(cs).test(0);\n+\n+            pp.onNext(0);\n+\n+            Runnable r1 = () -> pp.onNext(1);\n+\n+            Runnable r2 = () -> ts.request(3);\n+\n+            TestHelper.race(r1, r2);\n+\n+            cs.onSuccess(1);\n+            pp.onComplete();\n+\n+            ts.assertResult(0, 1, 1);\n+        }\n+    }\n+}\ndiff --git a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithSingleTest.java b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithSingleTest.java\nindex 269ed54..45e0059 100644\n--- a/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithSingleTest.java\n+++ b/src/test/java/io/reactivex/rxjava4/internal/operators/flowable/FlowableMergeWithSingleTest.java\n@@ -119,27 +119,6 @@ public class FlowableMergeWithSingleTest extends RxJavaTest {\n         .assertFailure(TestException.class);\n     }\n \n-    @Test\n-    public void completeRace() {\n-        for (int i = 0; i < 10000; i++) {\n-            final PublishProcessor<Integer> pp = PublishProcessor.create();\n-            final SingleSubject<Integer> cs = SingleSubject.create();\n-\n-            TestSubscriber<Integer> ts = pp.mergeWith(cs).test();\n-\n-            Runnable r1 = () -> {\n-                pp.onNext(1);\n-                pp.onComplete();\n-            };\n-\n-            Runnable r2 = () -> cs.onSuccess(1);\n-\n-            TestHelper.race(r1, r2);\n-\n-            ts.assertResult(1, 1);\n-        }\n-    }\n-\n     @Test\n     public void onNextSlowPath() {\n         final PublishProcessor<Integer> pp = PublishProcessor.create();\n@@ -211,27 +190,6 @@ public class FlowableMergeWithSingleTest extends RxJavaTest {\n         ts.assertResult(1, 2, 3);\n     }\n \n-    @Test\n-    public void onSuccessFastPathBackpressuredRace() {\n-        for (int i = 0; i < 10000; i++) {\n-            final PublishProcessor<Integer> pp = PublishProcessor.create();\n-            final SingleSubject<Integer> cs = SingleSubject.create();\n-\n-            final TestSubscriber<Integer> ts = pp.mergeWith(cs).subscribeWith(new TestSubscriber<>(0));\n-\n-            Runnable r1 = () -> cs.onSuccess(1);\n-\n-            Runnable r2 = () -> ts.request(2);\n-\n-            TestHelper.race(r1, r2);\n-\n-            pp.onNext(2);\n-            pp.onComplete();\n-\n-            ts.assertResult(1, 2);\n-        }\n-    }\n-\n     @Test\n     public void onErrorMainOverflow() {\n         List<Throwable> errors = TestHelper.trackPluginErrors();\n@@ -274,29 +232,6 @@ public class FlowableMergeWithSingleTest extends RxJavaTest {\n         }\n     }\n \n-    @Test\n-    public void onNextRequestRace() {\n-        for (int i = 0; i < 10000; i++) {\n-            final PublishProcessor<Integer> pp = PublishProcessor.create();\n-            final SingleSubject<Integer> cs = SingleSubject.create();\n-\n-            final TestSubscriber<Integer> ts = pp.mergeWith(cs).test(0);\n-\n-            pp.onNext(0);\n-\n-            Runnable r1 = () -> pp.onNext(1);\n-\n-            Runnable r2 = () -> ts.request(3);\n-\n-            TestHelper.race(r1, r2);\n-\n-            cs.onSuccess(1);\n-            pp.onComplete();\n-\n-            ts.assertResult(0, 1, 1);\n-        }\n-    }\n-\n     @Test\n     public void doubleOnSubscribeMain() {\n         TestHelper.checkDoubleOnSubscribeFlowable(\n","testEvidence":"211 tests, 0 failures/0 errors across 12 scoped classes (6 originals + 6 new @Isolated), eclipse-temurin:26-jdk pinned digest linux/arm64, network disconnected for test phase; checkstyleTest clean (online run); full-tree compileTestJava clean"},"role":"solution","schemaVersion":"jinn.execution.v1","signature":{"algo":"secp256k1","hash":"0x13eea7d133e46fd8ee2507d902fca7cdc7e21b2bcf6e6940884a3ae1f9378e45","sig":"0x0a416137e71761fc4570f73cac0f96e33620ddf1c874bb5ab2987186baf1367c5bd3961758f58f36e7eefdd9d70207d8836aa05b58a60c3838bfa2da796d2a8c01","signer":"0x654862876C8Ddaa048Fa9E0D32D5e0e81bD4Bd20"},"solverType":"external-repo-fix.manual.v1","task":{"baseCommit":"b7946f24fc6ec1f6bc984bcc2810024efbad744e","cid":"bafkreigi2difssipnkvkaa4ty566oscqiqq4iposeydcotse7zl5ikvhgi","onchainCreationTx":"0xd65e6123a8b1bd0f1e500f0b8acc519e56b106215ebd0356698f3bb387f223f1","repo":"ReactiveX/RxJava","requestId":"0xb87da104a22b9bfbf3932609961117d0987002aec013c3c8f61aaa67ae233ed5"}}