From 6cfab6591229e462ef62a3d7fc1b6ff3d34c228e Mon Sep 17 00:00:00 2001 From: jimi-21 Date: Mon, 16 Nov 2026 22:22:10 +0800 Subject: [PATCH 1/4] 4.x: Isolate Completable merge race tests --- .../CompletableMergeIterableIsolatedTest.java | 59 +++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 src/test/java/io/reactivex/rxjava4/internal/operators/completable/CompletableMergeIterableIsolatedTest.java diff --git a/src/test/java/io/reactivex/rxjava4/internal/operators/completable/CompletableMergeIterableIsolatedTest.java b/src/test/java/io/reactivex/rxjava4/internal/operators/completable/CompletableMergeIterableIsolatedTest.java new file mode 100644 index 0000000000..e703816680 --- /dev/null +++ b/src/test/java/io/reactivex/rxjava4/internal/operators/completable/CompletableMergeIterableIsolatedTest.java @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2016-present, RxJava Contributors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.rxjava4.internal.operators.completable; + +import java.util.*; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.parallel.Isolated; + +import io.reactivex.rxjava4.core.*; +import io.reactivex.rxjava4.exceptions.TestException; +import io.reactivex.rxjava4.observers.TestObserver; +import io.reactivex.rxjava4.plugins.RxJavaPlugins; +import io.reactivex.rxjava4.subjects.PublishSubject; +import io.reactivex.rxjava4.testsupport.TestHelper; + +@Isolated +public class CompletableMergeIterableIsolatedTest extends RxJavaTest { + + @Test + public void errorRace() { + for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) { + List errors = TestHelper.trackPluginErrors(); + try { + final PublishSubject ps1 = PublishSubject.create(); + final PublishSubject ps2 = PublishSubject.create(); + + TestObserver to = Completable.merge( + Arrays.asList(ps1.ignoreElements(), ps2.ignoreElements())).test(); + + final TestException ex = new TestException(); + + Runnable r1 = () -> ps1.onError(ex); + Runnable r2 = () -> ps2.onError(ex); + + TestHelper.race(r1, r2); + + to.assertFailure(TestException.class); + + if (!errors.isEmpty()) { + TestHelper.assertUndeliverable(errors, 0, TestException.class); + } + } finally { + RxJavaPlugins.reset(); + } + } + } +} From 0e5787aeb377474963fe34eb25bc0be12469a3e2 Mon Sep 17 00:00:00 2001 From: jimi-21 Date: Mon, 16 Nov 2026 22:22:13 +0800 Subject: [PATCH 2/4] 4.x: Isolate Completable merge race tests --- .../CompletableMergeIsolatedTest.java | 132 ++++++++++++++++++ 1 file changed, 132 insertions(+) create mode 100644 src/test/java/io/reactivex/rxjava4/internal/operators/completable/CompletableMergeIsolatedTest.java diff --git a/src/test/java/io/reactivex/rxjava4/internal/operators/completable/CompletableMergeIsolatedTest.java b/src/test/java/io/reactivex/rxjava4/internal/operators/completable/CompletableMergeIsolatedTest.java new file mode 100644 index 0000000000..7260410619 --- /dev/null +++ b/src/test/java/io/reactivex/rxjava4/internal/operators/completable/CompletableMergeIsolatedTest.java @@ -0,0 +1,132 @@ +/* + * Copyright (c) 2016-present, RxJava Contributors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.rxjava4.internal.operators.completable; + +import java.util.*; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.parallel.Isolated; + +import io.reactivex.rxjava4.core.*; +import io.reactivex.rxjava4.core.config.StandardConcurrentConfig; +import io.reactivex.rxjava4.exceptions.*; +import io.reactivex.rxjava4.observers.TestObserver; +import io.reactivex.rxjava4.plugins.RxJavaPlugins; +import io.reactivex.rxjava4.processors.PublishProcessor; +import io.reactivex.rxjava4.testsupport.*; + +@Isolated +public class CompletableMergeIsolatedTest extends RxJavaTest { + + @Test + public void mainErrorInnerErrorRace() { + for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) { + List errors = TestHelper.trackPluginErrors(); + try { + final PublishProcessor pp1 = PublishProcessor.create(); + final PublishProcessor pp2 = PublishProcessor.create(); + + TestObserverEx to = Completable.merge(pp1.map(_ -> pp2.ignoreElements())) + .to(TestHelper.testConsumer()); + + pp1.onNext(1); + + final Throwable ex1 = new TestException(); + final Throwable ex2 = new TestException(); + + Runnable r1 = () -> pp1.onError(ex1); + Runnable r2 = () -> pp2.onError(ex2); + + TestHelper.race(r1, r2); + + Throwable ex = to.errors().getFirst(); + if (ex instanceof CompositeException) { + to.assertSubscribed().assertNoValues().assertNotComplete(); + + errors = TestHelper.compositeList(ex); + TestHelper.assertError(errors, 0, TestException.class); + TestHelper.assertError(errors, 1, TestException.class); + } else { + to.assertFailure(TestException.class); + + if (!errors.isEmpty()) { + TestHelper.assertUndeliverable(errors, 0, TestException.class); + } + } + } finally { + RxJavaPlugins.reset(); + } + } + } + + @Test + public void mainErrorInnerErrorDelayedRace() { + for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) { + final PublishProcessor pp1 = PublishProcessor.create(); + final PublishProcessor pp2 = PublishProcessor.create(); + + TestObserverEx to = Completable.merge(pp1.map(_ -> pp2.ignoreElements()), StandardConcurrentConfig.MAX_DELAY_ERRORS) + .to(TestHelper.testConsumer()); + + pp1.onNext(1); + + final Throwable ex1 = new TestException(); + + Runnable r1 = () -> pp1.onError(ex1); + + final Throwable ex2 = new TestException(); + Runnable r2 = () -> pp2.onError(ex2); + + TestHelper.race(r1, r2); + + to.assertFailure(CompositeException.class); + + List errors = TestHelper.compositeList(to.errors().getFirst()); + + TestHelper.assertError(errors, 0, TestException.class); + TestHelper.assertError(errors, 1, TestException.class); + } + } + + @Test + public void mergeArrayInnerErrorRace() { + for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) { + List errors = TestHelper.trackPluginErrors(); + try { + final PublishProcessor pp1 = PublishProcessor.create(); + final PublishProcessor pp2 = PublishProcessor.create(); + + TestObserver to = Completable.mergeArray(pp1.ignoreElements(), pp2.ignoreElements()).test(); + + pp1.onNext(1); + + final Throwable ex1 = new TestException(); + final Throwable ex2 = new TestException(); + + Runnable r1 = () -> pp1.onError(ex1); + Runnable r2 = () -> pp2.onError(ex2); + + TestHelper.race(r1, r2); + + to.assertFailure(TestException.class); + + if (!errors.isEmpty()) { + TestHelper.assertUndeliverable(errors, 0, TestException.class); + } + } finally { + RxJavaPlugins.reset(); + } + } + } +} From 8c63ebe4f484bcf6786ba1f91de145d257959c7f Mon Sep 17 00:00:00 2001 From: jimi-21 Date: Mon, 16 Nov 2026 22:22:15 +0800 Subject: [PATCH 3/4] 4.x: Isolate Completable merge race tests --- .../CompletableMergeIterableTest.java | 29 ------------------- 1 file changed, 29 deletions(-) diff --git a/src/test/java/io/reactivex/rxjava4/internal/operators/completable/CompletableMergeIterableTest.java b/src/test/java/io/reactivex/rxjava4/internal/operators/completable/CompletableMergeIterableTest.java index 0405786dc8..776b8a447d 100644 --- a/src/test/java/io/reactivex/rxjava4/internal/operators/completable/CompletableMergeIterableTest.java +++ b/src/test/java/io/reactivex/rxjava4/internal/operators/completable/CompletableMergeIterableTest.java @@ -29,35 +29,6 @@ public class CompletableMergeIterableTest extends RxJavaTest { - @Test - public void errorRace() { - for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) { - List errors = TestHelper.trackPluginErrors(); - try { - final PublishSubject ps1 = PublishSubject.create(); - final PublishSubject ps2 = PublishSubject.create(); - - TestObserver to = Completable.merge( - Arrays.asList(ps1.ignoreElements(), ps2.ignoreElements())).test(); - - final TestException ex = new TestException(); - - Runnable r1 = () -> ps1.onError(ex); - Runnable r2 = () -> ps2.onError(ex); - - TestHelper.race(r1, r2); - - to.assertFailure(TestException.class); - - if (!errors.isEmpty()) { - TestHelper.assertUndeliverable(errors, 0, TestException.class); - } - } finally { - RxJavaPlugins.reset(); - } - } - } - @Test public void cancelAfterHasNext() { final TestObserver to = new TestObserver<>(); From 482bd1ff316cdf9afc1b240fc294584a36586593 Mon Sep 17 00:00:00 2001 From: jimi-21 Date: Mon, 16 Nov 2026 22:22:18 +0800 Subject: [PATCH 4/4] 4.x: Isolate Completable merge race tests --- .../completable/CompletableMergeTest.java | 101 ------------------ 1 file changed, 101 deletions(-) diff --git a/src/test/java/io/reactivex/rxjava4/internal/operators/completable/CompletableMergeTest.java b/src/test/java/io/reactivex/rxjava4/internal/operators/completable/CompletableMergeTest.java index fc52693661..6f3189fa6d 100644 --- a/src/test/java/io/reactivex/rxjava4/internal/operators/completable/CompletableMergeTest.java +++ b/src/test/java/io/reactivex/rxjava4/internal/operators/completable/CompletableMergeTest.java @@ -196,76 +196,6 @@ public void innerErrorDelayError() { to.assertFailure(TestException.class); } - @Test - public void mainErrorInnerErrorRace() { - for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) { - List errors = TestHelper.trackPluginErrors(); - try { - final PublishProcessor pp1 = PublishProcessor.create(); - final PublishProcessor pp2 = PublishProcessor.create(); - - TestObserverEx to = Completable.merge(pp1.map(_ -> pp2.ignoreElements())) - .to(TestHelper.testConsumer()); - - pp1.onNext(1); - - final Throwable ex1 = new TestException(); - final Throwable ex2 = new TestException(); - - Runnable r1 = () -> pp1.onError(ex1); - Runnable r2 = () -> pp2.onError(ex2); - - TestHelper.race(r1, r2); - - Throwable ex = to.errors().getFirst(); - if (ex instanceof CompositeException) { - to.assertSubscribed().assertNoValues().assertNotComplete(); - - errors = TestHelper.compositeList(ex); - TestHelper.assertError(errors, 0, TestException.class); - TestHelper.assertError(errors, 1, TestException.class); - } else { - to.assertFailure(TestException.class); - - if (!errors.isEmpty()) { - TestHelper.assertUndeliverable(errors, 0, TestException.class); - } - } - } finally { - RxJavaPlugins.reset(); - } - } - } - - @Test - public void mainErrorInnerErrorDelayedRace() { - for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) { - final PublishProcessor pp1 = PublishProcessor.create(); - final PublishProcessor pp2 = PublishProcessor.create(); - - TestObserverEx to = Completable.merge(pp1.map(_ -> pp2.ignoreElements()), StandardConcurrentConfig.MAX_DELAY_ERRORS) - .to(TestHelper.testConsumer()); - - pp1.onNext(1); - - final Throwable ex1 = new TestException(); - - Runnable r1 = () -> pp1.onError(ex1); - - final Throwable ex2 = new TestException(); - Runnable r2 = () -> pp2.onError(ex2); - - TestHelper.race(r1, r2); - - to.assertFailure(CompositeException.class); - - List errors = TestHelper.compositeList(to.errors().getFirst()); - - TestHelper.assertError(errors, 0, TestException.class); - TestHelper.assertError(errors, 1, TestException.class); - } - } - @Test public void maxConcurrencyOne() { final PublishProcessor pp1 = PublishProcessor.create(); @@ -419,37 +349,6 @@ protected void subscribeActual(CompletableObserver observer) { .subscribe(to); } - @Test - public void mergeArrayInnerErrorRace() { - for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) { - List errors = TestHelper.trackPluginErrors(); - try { - final PublishProcessor pp1 = PublishProcessor.create(); - final PublishProcessor pp2 = PublishProcessor.create(); - - TestObserver to = Completable.mergeArray(pp1.ignoreElements(), pp2.ignoreElements()).test(); - - pp1.onNext(1); - - final Throwable ex1 = new TestException(); - final Throwable ex2 = new TestException(); - - Runnable r1 = () -> pp1.onError(ex1); - Runnable r2 = () -> pp2.onError(ex2); - - TestHelper.race(r1, r2); - - to.assertFailure(TestException.class); - - if (!errors.isEmpty()) { - TestHelper.assertUndeliverable(errors, 0, TestException.class); - } - } finally { - RxJavaPlugins.reset(); - } - } - } - @Test public void delayErrorIterableCancel() { Completable.merge(Collections.singletonList(Completable.complete()), StandardConcurrentConfig.MAX_DELAY_ERRORS)