*
*
*
+ * 
+ *
+ * 
+ *
* 
*
* 
*
+ * 
+ *
+ * 
+ *
+ * 
+ *
+ * 
+ *
+ * 
+ *
+ * 
+ *
+ * 
+ *
+ * 
+ *
diff --git a/src/main/java/io/reactivex/rxjava3/core/Observable.java b/src/main/java/io/reactivex/rxjava3/core/Observable.java
index 3ab0be1ab9..6db7ce3cc1 100644
--- a/src/main/java/io/reactivex/rxjava3/core/Observable.java
+++ b/src/main/java/io/reactivex/rxjava3/core/Observable.java
@@ -12704,6 +12704,72 @@ public final Observable
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
diff --git a/src/test/java/io/reactivex/rxjava3/internal/operators/completable/CompletableStartWithTest.java b/src/test/java/io/reactivex/rxjava3/internal/operators/completable/CompletableStartWithTest.java
new file mode 100644
index 0000000000..065a600a0e
--- /dev/null
+++ b/src/test/java/io/reactivex/rxjava3/internal/operators/completable/CompletableStartWithTest.java
@@ -0,0 +1,67 @@
+/**
+ * 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.rxjava3.internal.operators.completable;
+
+import static org.mockito.Mockito.*;
+
+import org.junit.Test;
+
+import io.reactivex.rxjava3.core.*;
+import io.reactivex.rxjava3.exceptions.TestException;
+
+public class CompletableStartWithTest {
+
+ @Test
+ public void singleNormal() {
+ Completable.complete().startWith(Single.just(1))
+ .test()
+ .assertResult(1);
+ }
+
+ @Test
+ public void singleError() {
+ Runnable run = mock(Runnable.class);
+
+ Completable.fromRunnable(run).startWith(Single.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+
+ verify(run, never()).run();
+ }
+
+ @Test
+ public void maybeNormal() {
+ Completable.complete().startWith(Maybe.just(1))
+ .test()
+ .assertResult(1);
+ }
+
+ @Test
+ public void maybeEmptyNormal() {
+ Completable.complete().startWith(Maybe.empty())
+ .test()
+ .assertResult();
+ }
+
+ @Test
+ public void maybeError() {
+ Runnable run = mock(Runnable.class);
+
+ Completable.fromRunnable(run).startWith(Maybe.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+
+ verify(run, never()).run();
+ }
+}
diff --git a/src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableStartWithTest.java b/src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableStartWithTest.java
new file mode 100644
index 0000000000..68f4ee6272
--- /dev/null
+++ b/src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableStartWithTest.java
@@ -0,0 +1,153 @@
+/**
+ * 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.rxjava3.internal.operators.flowable;
+
+import static org.mockito.Mockito.*;
+
+import org.junit.Test;
+
+import io.reactivex.rxjava3.core.*;
+import io.reactivex.rxjava3.exceptions.TestException;
+
+public class FlowableStartWithTest {
+
+ @Test
+ public void justCompletableComplete() {
+ Flowable.just(1).startWith(Completable.complete())
+ .test()
+ .assertResult(1);
+ }
+
+ @Test
+ public void emptyCompletableComplete() {
+ Flowable.empty().startWith(Completable.complete())
+ .test()
+ .assertResult();
+ }
+
+ @Test
+ public void runCompletableError() {
+ Runnable run = mock(Runnable.class);
+
+ Flowable.fromRunnable(run).startWith(Completable.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+
+ verify(run, never()).run();
+ }
+
+ @Test
+ public void justSingleJust() {
+ Flowable.just(1).startWith(Single.just(2))
+ .test()
+ .assertResult(2, 1);
+ }
+
+ @Test
+ public void emptySingleJust() {
+ Runnable run = mock(Runnable.class);
+
+ Flowable.fromRunnable(run)
+ .startWith(Single.just(2))
+ .test()
+ .assertResult(2);
+
+ verify(run).run();
+ }
+
+ @Test
+ public void runSingleError() {
+ Runnable run = mock(Runnable.class);
+
+ Flowable.fromRunnable(run).startWith(Single.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+
+ verify(run, never()).run();
+ }
+
+ @Test
+ public void justMaybeJust() {
+ Flowable.just(1).startWith(Maybe.just(2))
+ .test()
+ .assertResult(2, 1);
+ }
+
+ @Test
+ public void emptyMaybeJust() {
+ Runnable run = mock(Runnable.class);
+
+ Flowable.fromRunnable(run)
+ .startWith(Maybe.just(2))
+ .test()
+ .assertResult(2);
+
+ verify(run).run();
+ }
+
+ @Test
+ public void runMaybeError() {
+ Runnable run = mock(Runnable.class);
+
+ Flowable.fromRunnable(run).startWith(Maybe.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+
+ verify(run, never()).run();
+ }
+
+ @Test
+ public void justFlowableJust() {
+ Flowable.just(1).startWith(Flowable.just(2, 3, 4, 5))
+ .test()
+ .assertResult(2, 3, 4, 5, 1);
+ }
+
+ @Test
+ public void emptyFlowableJust() {
+ Runnable run = mock(Runnable.class);
+
+ Flowable.fromRunnable(run)
+ .startWith(Flowable.just(2, 3, 4, 5))
+ .test()
+ .assertResult(2, 3, 4, 5);
+
+ verify(run).run();
+ }
+
+ @Test
+ public void emptyFlowableEmpty() {
+ Runnable run = mock(Runnable.class);
+ Runnable run2 = mock(Runnable.class);
+
+ Flowable.fromRunnable(run)
+ .startWith(Flowable.fromRunnable(run2))
+ .test()
+ .assertResult();
+
+ verify(run).run();
+ verify(run2).run();
+ }
+
+ @Test
+ public void runFlowableError() {
+ Runnable run = mock(Runnable.class);
+
+ Flowable.fromRunnable(run).startWith(Flowable.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+
+ verify(run, never()).run();
+ }
+}
diff --git a/src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeStartWithTest.java b/src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeStartWithTest.java
new file mode 100644
index 0000000000..87969974d4
--- /dev/null
+++ b/src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeStartWithTest.java
@@ -0,0 +1,197 @@
+/**
+ * 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.rxjava3.internal.operators.maybe;
+
+import static org.mockito.Mockito.*;
+
+import org.junit.Test;
+
+import io.reactivex.rxjava3.core.*;
+import io.reactivex.rxjava3.exceptions.TestException;
+
+public class MaybeStartWithTest {
+
+ @Test
+ public void justCompletableComplete() {
+ Maybe.just(1).startWith(Completable.complete())
+ .test()
+ .assertResult(1);
+ }
+
+ @Test
+ public void emptyCompletableComplete() {
+ Maybe.empty().startWith(Completable.complete())
+ .test()
+ .assertResult();
+ }
+
+ @Test
+ public void runCompletableError() {
+ Runnable run = mock(Runnable.class);
+
+ Maybe.fromRunnable(run).startWith(Completable.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+
+ verify(run, never()).run();
+ }
+
+ @Test
+ public void justSingleJust() {
+ Maybe.just(1).startWith(Single.just(2))
+ .test()
+ .assertResult(2, 1);
+ }
+
+ @Test
+ public void emptySingleJust() {
+ Runnable run = mock(Runnable.class);
+
+ Maybe.fromRunnable(run)
+ .startWith(Single.just(2))
+ .test()
+ .assertResult(2);
+
+ verify(run).run();
+ }
+
+ @Test
+ public void runSingleError() {
+ Runnable run = mock(Runnable.class);
+
+ Maybe.fromRunnable(run).startWith(Single.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+
+ verify(run, never()).run();
+ }
+
+ @Test
+ public void justMaybeJust() {
+ Maybe.just(1).startWith(Maybe.just(2))
+ .test()
+ .assertResult(2, 1);
+ }
+
+ @Test
+ public void emptyMaybeJust() {
+ Runnable run = mock(Runnable.class);
+
+ Maybe.fromRunnable(run)
+ .startWith(Maybe.just(2))
+ .test()
+ .assertResult(2);
+
+ verify(run).run();
+ }
+
+ @Test
+ public void runMaybeError() {
+ Runnable run = mock(Runnable.class);
+
+ Maybe.fromRunnable(run).startWith(Maybe.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+
+ verify(run, never()).run();
+ }
+
+ @Test
+ public void justObservableJust() {
+ Maybe.just(1).startWith(Observable.just(2, 3, 4, 5))
+ .test()
+ .assertResult(2, 3, 4, 5, 1);
+ }
+
+ @Test
+ public void emptyObservableJust() {
+ Runnable run = mock(Runnable.class);
+
+ Maybe.fromRunnable(run)
+ .startWith(Observable.just(2, 3, 4, 5))
+ .test()
+ .assertResult(2, 3, 4, 5);
+
+ verify(run).run();
+ }
+
+ @Test
+ public void emptyObservableEmpty() {
+ Runnable run = mock(Runnable.class);
+ Runnable run2 = mock(Runnable.class);
+
+ Maybe.fromRunnable(run)
+ .startWith(Observable.fromRunnable(run2))
+ .test()
+ .assertResult();
+
+ verify(run).run();
+ verify(run2).run();
+ }
+
+ @Test
+ public void runObservableError() {
+ Runnable run = mock(Runnable.class);
+
+ Maybe.fromRunnable(run).startWith(Observable.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+
+ verify(run, never()).run();
+ }
+
+ @Test
+ public void justFlowableJust() {
+ Maybe.just(1).startWith(Flowable.just(2, 3, 4, 5))
+ .test()
+ .assertResult(2, 3, 4, 5, 1);
+ }
+
+ @Test
+ public void emptyFlowableJust() {
+ Runnable run = mock(Runnable.class);
+
+ Maybe.fromRunnable(run)
+ .startWith(Flowable.just(2, 3, 4, 5))
+ .test()
+ .assertResult(2, 3, 4, 5);
+
+ verify(run).run();
+ }
+
+ @Test
+ public void emptyFlowableEmpty() {
+ Runnable run = mock(Runnable.class);
+ Runnable run2 = mock(Runnable.class);
+
+ Maybe.fromRunnable(run)
+ .startWith(Flowable.fromRunnable(run2))
+ .test()
+ .assertResult();
+
+ verify(run).run();
+ verify(run2).run();
+ }
+
+ @Test
+ public void runFlowableError() {
+ Runnable run = mock(Runnable.class);
+
+ Maybe.fromRunnable(run).startWith(Flowable.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+
+ verify(run, never()).run();
+ }
+}
diff --git a/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableStartWithTest.java b/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableStartWithTest.java
new file mode 100644
index 0000000000..47cf4dc962
--- /dev/null
+++ b/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableStartWithTest.java
@@ -0,0 +1,153 @@
+/**
+ * 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.rxjava3.internal.operators.observable;
+
+import static org.mockito.Mockito.*;
+
+import org.junit.Test;
+
+import io.reactivex.rxjava3.core.*;
+import io.reactivex.rxjava3.exceptions.TestException;
+
+public class ObservableStartWithTest {
+
+ @Test
+ public void justCompletableComplete() {
+ Observable.just(1).startWith(Completable.complete())
+ .test()
+ .assertResult(1);
+ }
+
+ @Test
+ public void emptyCompletableComplete() {
+ Observable.empty().startWith(Completable.complete())
+ .test()
+ .assertResult();
+ }
+
+ @Test
+ public void runCompletableError() {
+ Runnable run = mock(Runnable.class);
+
+ Observable.fromRunnable(run).startWith(Completable.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+
+ verify(run, never()).run();
+ }
+
+ @Test
+ public void justSingleJust() {
+ Observable.just(1).startWith(Single.just(2))
+ .test()
+ .assertResult(2, 1);
+ }
+
+ @Test
+ public void emptySingleJust() {
+ Runnable run = mock(Runnable.class);
+
+ Observable.fromRunnable(run)
+ .startWith(Single.just(2))
+ .test()
+ .assertResult(2);
+
+ verify(run).run();
+ }
+
+ @Test
+ public void runSingleError() {
+ Runnable run = mock(Runnable.class);
+
+ Observable.fromRunnable(run).startWith(Single.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+
+ verify(run, never()).run();
+ }
+
+ @Test
+ public void justMaybeJust() {
+ Observable.just(1).startWith(Maybe.just(2))
+ .test()
+ .assertResult(2, 1);
+ }
+
+ @Test
+ public void emptyMaybeJust() {
+ Runnable run = mock(Runnable.class);
+
+ Observable.fromRunnable(run)
+ .startWith(Maybe.just(2))
+ .test()
+ .assertResult(2);
+
+ verify(run).run();
+ }
+
+ @Test
+ public void runMaybeError() {
+ Runnable run = mock(Runnable.class);
+
+ Observable.fromRunnable(run).startWith(Maybe.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+
+ verify(run, never()).run();
+ }
+
+ @Test
+ public void justObservableJust() {
+ Observable.just(1).startWith(Observable.just(2, 3, 4, 5))
+ .test()
+ .assertResult(2, 3, 4, 5, 1);
+ }
+
+ @Test
+ public void emptyObservableJust() {
+ Runnable run = mock(Runnable.class);
+
+ Observable.fromRunnable(run)
+ .startWith(Observable.just(2, 3, 4, 5))
+ .test()
+ .assertResult(2, 3, 4, 5);
+
+ verify(run).run();
+ }
+
+ @Test
+ public void emptyObservableEmpty() {
+ Runnable run = mock(Runnable.class);
+ Runnable run2 = mock(Runnable.class);
+
+ Observable.fromRunnable(run)
+ .startWith(Observable.fromRunnable(run2))
+ .test()
+ .assertResult();
+
+ verify(run).run();
+ verify(run2).run();
+ }
+
+ @Test
+ public void runObservableError() {
+ Runnable run = mock(Runnable.class);
+
+ Observable.fromRunnable(run).startWith(Observable.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+
+ verify(run, never()).run();
+ }
+}
diff --git a/src/test/java/io/reactivex/rxjava3/internal/operators/single/SingleStartWithTest.java b/src/test/java/io/reactivex/rxjava3/internal/operators/single/SingleStartWithTest.java
new file mode 100644
index 0000000000..a3f7e7225a
--- /dev/null
+++ b/src/test/java/io/reactivex/rxjava3/internal/operators/single/SingleStartWithTest.java
@@ -0,0 +1,126 @@
+/**
+ * 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.rxjava3.internal.operators.single;
+
+import org.junit.Test;
+
+import io.reactivex.rxjava3.core.*;
+import io.reactivex.rxjava3.exceptions.TestException;
+
+public class SingleStartWithTest {
+
+ @Test
+ public void justCompletableComplete() {
+ Single.just(1)
+ .startWith(Completable.complete())
+ .test()
+ .assertResult(1);
+ }
+
+ @Test
+ public void justCompletableError() {
+ Single.just(1)
+ .startWith(Completable.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+ }
+
+ @Test
+ public void justSingleJust() {
+ Single.just(1)
+ .startWith(Single.just(0))
+ .test()
+ .assertResult(0, 1);
+ }
+
+ @Test
+ public void justSingleError() {
+ Single.just(1)
+ .startWith(Single.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+ }
+
+ @Test
+ public void justMaybeJust() {
+ Single.just(1)
+ .startWith(Maybe.just(0))
+ .test()
+ .assertResult(0, 1);
+ }
+
+ @Test
+ public void justMaybeEmpty() {
+ Single.just(1)
+ .startWith(Maybe.empty())
+ .test()
+ .assertResult(1);
+ }
+
+ @Test
+ public void justMaybeError() {
+ Single.just(1)
+ .startWith(Maybe.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+ }
+
+ @Test
+ public void justObservableJust() {
+ Single.just(1)
+ .startWith(Observable.just(-1, 0))
+ .test()
+ .assertResult(-1, 0, 1);
+ }
+
+ @Test
+ public void justObservableEmpty() {
+ Single.just(1)
+ .startWith(Observable.empty())
+ .test()
+ .assertResult(1);
+ }
+
+ @Test
+ public void justObservableError() {
+ Single.just(1)
+ .startWith(Observable.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+ }
+
+ @Test
+ public void justFlowableJust() {
+ Single.just(1)
+ .startWith(Flowable.just(-1, 0))
+ .test()
+ .assertResult(-1, 0, 1);
+ }
+
+ @Test
+ public void justFlowableEmpty() {
+ Single.just(1)
+ .startWith(Observable.empty())
+ .test()
+ .assertResult(1);
+ }
+
+ @Test
+ public void justFlowableError() {
+ Single.just(1)
+ .startWith(Flowable.error(new TestException()))
+ .test()
+ .assertFailure(TestException.class);
+ }
+}
+ *
+ *
+ * @param other the other {@code CompletableSource} to run first
+ * @return the new {@code Observable} instance
+ * @throws NullPointerException if {@code other} is {@code null}
+ * @since 3.0.0
+ */
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(SchedulerSupport.NONE)
+ public final Observable
+ *
+ *
+ * @param other the other {@code SingleSource} to run first
+ * @return the new {@code Observable} instance
+ * @throws NullPointerException if {@code other} is {@code null}
+ * @since 3.0.0
+ */
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(SchedulerSupport.NONE)
+ public final Observable
+ *
+ *
+ * @param other the other {@code MaybeSource} to run first
+ * @return the new {@code Observable} instance
+ * @throws NullPointerException if {@code other} is {@code null}
+ * @since 3.0.0
+ */
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(SchedulerSupport.NONE)
+ public final Observable
+ *
+ *
+ * @param other the other {@code CompletableSource} to run first
+ * @return the new {@code Flowable} instance
+ * @throws NullPointerException if {@code other} is {@code null}
+ * @since 3.0.0
+ */
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(SchedulerSupport.NONE)
+ @BackpressureSupport(BackpressureKind.FULL)
+ public final Flowable
+ *
+ *
+ * @param other the other {@code SingleSource} to run first
+ * @return the new {@code Flowable} instance
+ * @throws NullPointerException if {@code other} is {@code null}
+ * @since 3.0.0
+ */
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(SchedulerSupport.NONE)
+ @BackpressureSupport(BackpressureKind.FULL)
+ public final Flowable
+ *
+ *
+ * @param other the other {@code MaybeSource} to run first
+ * @return the new {@code Flowable} instance
+ * @throws NullPointerException if {@code other} is {@code null}
+ * @since 3.0.0
+ */
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(SchedulerSupport.NONE)
+ @BackpressureSupport(BackpressureKind.FULL)
+ public final Flowable
+ *
+ *
+ * @param other the other {@code ObservableSource} to run first
+ * @return the new {@code Observable} instance
+ * @throws NullPointerException if {@code other} is {@code null}
+ * @since 3.0.0
+ */
+ @CheckReturnValue
+ @NonNull
+ @SchedulerSupport(SchedulerSupport.NONE)
+ public final Observable
+ *
+ *
+ * @param other the other {@code Publisher} to run first
+ * @return the new {@code Flowable} instance
+ * @throws NullPointerException if {@code other} is {@code null}
+ * @since 3.0.0
+ */
+ @CheckReturnValue
+ @NonNull
+ @BackpressureSupport(BackpressureKind.FULL)
+ @SchedulerSupport(SchedulerSupport.NONE)
+ public final Flowable