diff --git a/.travis.yml b/.travis.yml index 83835caeba..9c5c0f6909 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,6 +1,6 @@ language: java jdk: -- oraclejdk8 +- openjdk8 # force upgrade Java8 as per https://github.com/travis-ci/travis-ci/issues/4042 (fixes compilation issue) #addons: diff --git a/CHANGES.md b/CHANGES.md index dd1266c545..8842673756 100644 --- a/CHANGES.md +++ b/CHANGES.md @@ -2,6 +2,231 @@ The changelog of version 1.x can be found at https://github.com/ReactiveX/RxJava/blob/1.x/CHANGES.md +### Version 2.2.21 - February 10, 2021 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.21%7C)) +[JavaDocs](http://reactivex.io/RxJava/2.x/javadoc/2.2.21) + +:warning: This is the last planned update for the 2.x version line. After **February 28, 2021**, 2.x becomes **End-of-Life** (EoL); no further patches, bugfixes, enhancements, documentation or support will be provided by the project. + + +#### Enhancements + +- Add a system parameter to allow scheduled worker release in the Io `Scheduler`. (#7162) +- Add a system parameter to allow `Scheduler`s to use `System.nanoTime()` for `now()`. (#7170) + +### Version 2.2.20 - October 6, 2020 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.20%7C)) +[JavaDocs](http://reactivex.io/RxJava/2.x/javadoc/2.2.20) + +:warning: The 2.x version line is now in **maintenance mode** and will be supported only through bugfixes until **February 28, 2021**. No new features, behavior changes or documentation adjustments will be accepted or applied to 2.x. It is recommended to migrate to [3.x](https://github.com/ReactiveX/RxJava/tree/3.x) within this time period. + +#### Bugfixes + +- Fix `Observable.flatMap` with `maxConcurrency` hangs (#6960) +- Fix `Observable.toFlowable(ERROR)` not cancelling upon `MissingBackpressureException` (#7084) +- Fix `Flowable.concatMap` backpressure with scalars. (#7091) + +### Version 2.2.19 - March 14, 2020 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.19%7C)) +[JavaDocs](http://reactivex.io/RxJava/2.x/javadoc/2.2.19) + +:warning: The 2.x version line is now in **maintenance mode** and will be supported only through bugfixes until **February 28, 2021**. No new features, behavior changes or documentation adjustments will be accepted or applied to 2.x. It is recommended to migrate to [3.x](https://github.com/ReactiveX/RxJava/tree/3.x) within this time period. + +#### Bugfixes + + - [Commit 7980c85b](https://github.com/ReactiveX/RxJava/commit/7980c85b18dd46ec2cd2cf49477363f1268d3a98): Fix `switchMap` not canceling properly during `onNext`-`cancel` races. + + +### Version 2.2.18 - February 21, 2020 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.18%7C)) + +:warning: The 2.x version line is now in **maintenance mode** and will be supported only through bugfixes until **February 28, 2021**. No new features, behavior changes or documentation adjustments will be accepted or applied to 2.x. It is recommended to migrate to [3.x](https://github.com/ReactiveX/RxJava/tree/3.x) within this time period. + +#### Bugfixes + + - [Pull 6894](https://github.com/ReactiveX/RxJava/pull/6894): Fix `groupBy` not requesting more if a group is cancelled with buffered items. + +### Version 2.2.17 - January 12, 2020 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.17%7C)) + +#### Bugfixes + + - [Pull 6827](https://github.com/ReactiveX/RxJava/pull/6827): Fix `Flowable.flatMap` not canceling the inner sources on outer error. + +### Version 2.2.16 - December 15, 2019 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.16%7C)) + +#### Bugfixes + + - [Pull 6754](https://github.com/ReactiveX/RxJava/pull/6754): Fix `amb`, `combineLatest` and `zip` `Iterable` overloads throwing `ArrayStoreException` for `ObservableSource`s. + +#### Documentation changes + + - [Pull 6746](https://github.com/ReactiveX/RxJava/pull/6746): Fix self-see references, some comments. + +### Version 2.2.15 - November 24, 2019 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.15%7C)) + +#### Bugfixes + + - [Pull 6715](https://github.com/ReactiveX/RxJava/pull/6715): Fix `MulticastProcessor` not requesting more after limit is reached. + - [Pull 6710](https://github.com/ReactiveX/RxJava/pull/6710): Fix concurrent `clear` in `observeOn` while output-fused. + - [Pull 6720](https://github.com/ReactiveX/RxJava/pull/6720): Fix `parallel()` on grouped flowable not replenishing properly. + +#### Documentation changes + + - [Pull 6722](https://github.com/ReactiveX/RxJava/pull/6722): Update javadoc for `observeOn` to mention its eagerness. + +#### Other changes + + - [Pull 6704](https://github.com/ReactiveX/RxJava/pull/6704): Add ProGuard rule to avoid `j.u.c.Flow` warnings due to RS 1.0.3. + +### Version 2.2.14 - November 2, 2019 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.14%7C)) + +#### Bugfixes + + - [Pull 6677](https://github.com/ReactiveX/RxJava/pull/6677): Fix concurrent `clear()` calls when fused chains are canceled. + - [Pull 6684](https://github.com/ReactiveX/RxJava/pull/6684): Fix `window(time)` possible interrupts while terminating. + +#### Documentation changes + + - [Pull 6681](https://github.com/ReactiveX/RxJava/pull/6681): Backport marble diagrams for `Single` from 3.x. + +### Version 2.2.13 - October 3, 2019 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.13%7C)) + +#### Dependencies + + - [Commit cc690ff2](https://github.com/ReactiveX/RxJava/commit/cc690ff2f757873b11cd075ebc22262f76f28459): Upgrade to **Reactive Streams 1.0.3**. + +#### Bugfixes + + - [Commit cc690ff2](https://github.com/ReactiveX/RxJava/commit/cc690ff2f757873b11cd075ebc22262f76f28459): Avoid using `System.getProperties()`. + - [Pull 6653](https://github.com/ReactiveX/RxJava/pull/6653): Fix `takeLast(time)` last events time window calculation. + - [Pull 6657](https://github.com/ReactiveX/RxJava/pull/6657): Fix size+time bound `window` not creating windows properly. + +### Version 2.2.12 - August 25, 2019 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.12%7C)) + +#### Bugfixes + + - [Pull 6618](https://github.com/ReactiveX/RxJava/pull/6618): Fix `switchMap` incorrect sync-fusion & error management. + - [Pull 6627](https://github.com/ReactiveX/RxJava/pull/6627): Fix `blockingIterable` hang when force-disposed. + - [Pull 6629](https://github.com/ReactiveX/RxJava/pull/6629): Fix `refCount` not resetting when cross-canceled. + +### Version 2.2.11 - August 2, 2019 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.11%7C)) + +#### Bugfixes + + - [Pull 6560](https://github.com/ReactiveX/RxJava/pull/6560): Fix NPE when debouncing an empty source. + - [Pull 6599](https://github.com/ReactiveX/RxJava/pull/6599): Fix `mergeWith` not canceling other when the main fails. + - [Pull 6601](https://github.com/ReactiveX/RxJava/pull/6601): `ObservableBlockingSubscribe` compares with wrong object. + - [Pull 6602](https://github.com/ReactiveX/RxJava/pull/): Fix truncation bugs in `replay()` and `ReplaySubject`/`Processor`. + +#### Documentation changes + + - [Pull 6565](https://github.com/ReactiveX/RxJava/pull/6565): Fix JavaDocs of `Single.doOnTerminate` refer to `onComplete` notification. + +### Version 2.2.10 - June 21, 2019 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.10%7C)) + +#### Bugfixes + + - [Pull 6499](https://github.com/ReactiveX/RxJava/pull/6499): Add missing null check to `BufferExactBoundedObserver`. + - [Pull 6505](https://github.com/ReactiveX/RxJava/pull/6505): Fix `publish().refCount()` hang due to race. + - [Pull 6522](https://github.com/ReactiveX/RxJava/pull/6522): Fix `concatMapDelayError` not continuing on fused inner source crash. + +#### Documentation changes + + - [Pull 6496](https://github.com/ReactiveX/RxJava/pull/6496): Fix outdated links in `Additional-Reading.md`. + - [Pull 6497](https://github.com/ReactiveX/RxJava/pull/6497): Fix links in `Alphabetical-List-of-Observable-Operators.md`. + - [Pull 6504](https://github.com/ReactiveX/RxJava/pull/6504): Fix various Javadocs & imports. + - [Pull 6506](https://github.com/ReactiveX/RxJava/pull/6506): Expand the Javadoc of `Flowable`. + - [Pull 6510](https://github.com/ReactiveX/RxJava/pull/6510): Correct "Reactive-Streams" to "Reactive Streams" in documentation. + +### Version 2.2.9 - May 30, 2019 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.9%7C)) + +#### Bugfixes + + - [Pull 6488](https://github.com/ReactiveX/RxJava/pull/6488): Fix `zip` not stopping the subscription upon eager error. + +#### Documentation changes + + - [Pull 6453](https://github.com/ReactiveX/RxJava/pull/6453): Fixed wrong type referenced in `Maybe` and `Single` JavaDocs. + - [Pull 6458](https://github.com/ReactiveX/RxJava/pull/6458): Update the Javadoc of the `retry` operator. + +#### Other + + - [Pull 6452](https://github.com/ReactiveX/RxJava/pull/6452): Remove dependency of `Schedulers` from `ObservableRefCount`. + - [Pull 6461](https://github.com/ReactiveX/RxJava/pull/6461): Change error message in `ObservableFromArray`. + - [Pull 6469](https://github.com/ReactiveX/RxJava/pull/6469): Remove redundant methods from `sample(Observable)`. + - [Pull 6470](https://github.com/ReactiveX/RxJava/pull/6470): Remove unused import from `Flowable.java`. + - [Pull 6485](https://github.com/ReactiveX/RxJava/pull/6485): Remove unused `else` from the `Observable`. + +### Version 2.2.8 - March 26, 2019 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.8%7C)) + +#### Bugfixes + + - [Pull 6442](https://github.com/ReactiveX/RxJava/pull/6442): Add missing undeliverable error handling logic for `Completable.fromRunnable` & `fromAction` operators. + +#### Documentation changes + + - [Pull 6432](https://github.com/ReactiveX/RxJava/pull/6432): Improve the docs of `CompositeDisposable`. + - [Pull 6434](https://github.com/ReactiveX/RxJava/pull/6434): Improve subjects and processors package doc. + - [Pull 6436](https://github.com/ReactiveX/RxJava/pull/6436): Improve `Creating-Observables` wiki doc. + + +#### Other + + - [Pull 6433](https://github.com/ReactiveX/RxJava/pull/6433): Make error messages of parameter checks consistent. + +### Version 2.2.7 - February 23, 2019 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.7%7C)) + +#### API enhancements + + - [Pull 6386](https://github.com/ReactiveX/RxJava/pull/6386): Add `doOnTerminate` to `Single`/`Maybe` for consistency. + +#### Bugfixes + + - [Pull 6405](https://github.com/ReactiveX/RxJava/pull/6405): Fix concatEager to dispose sources & clean up properly. + - [Pull 6398](https://github.com/ReactiveX/RxJava/pull/6398): Fix `window()` with start/end selector not disposing/cancelling properly. + +#### Documentation changes + + - [Pull 6377](https://github.com/ReactiveX/RxJava/pull/6377): Expand `Observable#debounce` and `Flowable#debounce` javadoc. + - [Pull 6408](https://github.com/ReactiveX/RxJava/pull/6408): Improving Javadoc of `flattenAsFlowable` and `flattenAsObservable` methods. + +### Version 2.2.6 - January 23, 2019 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.6%7C)) + +#### API enhancements + + - [Pull 6370](https://github.com/ReactiveX/RxJava/pull/6370): Add interruptible mode via the new `Schedulers.from(Executor, boolean)` overload. + +#### Bugfixes + + - [Pull 6359](https://github.com/ReactiveX/RxJava/pull/6359): Fix the error/race in `Observable.repeatWhen` due to flooding repeat signal. + - [Pull 6362 ](https://github.com/ReactiveX/RxJava/pull/6362 ): Fix `Completable.andThen(Completable)` not running on `observeOn`'s `Scheduler`. + - [Pull 6364](https://github.com/ReactiveX/RxJava/pull/6364): Fix `Flowable.publish` not requesting upon client change. + - [Pull 6371](https://github.com/ReactiveX/RxJava/pull/6371): Fix bounded `replay()` memory leak due to bad node retention. + - [Pull 6375](https://github.com/ReactiveX/RxJava/pull/6375): Don't dispose the winner of `{Single|Maybe|Completable}.amb()`. + - [Pull 6380](https://github.com/ReactiveX/RxJava/pull/6380): Fix `CompositeException.getRootCause()` detecting loops in the cause graph. + +#### Documentation changes + + - [Pull 6365](https://github.com/ReactiveX/RxJava/pull/6365): Indicate source disposal in `timeout(fallback)`. + +#### Other changes + + - [Pull 6353](https://github.com/ReactiveX/RxJava/pull/6353): Use `ignoreElement` to convert `Single` to `Completable` in the `README.md`. + +### Version 2.2.5 - December 31, 2018 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.5%7C)) + +#### Documentation changes + + - [Pull 6344](https://github.com/ReactiveX/RxJava/pull/6344): Use correct return type in JavaDocs documentation in `elementAtOrDefault`. + - [Pull 6346](https://github.com/ReactiveX/RxJava/pull/6346): Fix JavaDoc examples using markdown instead of `@code`. + +#### Wiki changes + + - [Pull 6324](https://github.com/ReactiveX/RxJava/pull/6324): Java 8 version for [Problem-Solving-Examples-in-RxJava](https://github.com/ReactiveX/RxJava/wiki/Problem-Solving-Examples-in-RxJava). + - [Pull 6343](https://github.com/ReactiveX/RxJava/pull/6343): Update [Filtering Observables](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables) docs. + - [Pull 6351](https://github.com/ReactiveX/RxJava/pull/6351): Updated java example in [How-To-Use-RxJava.md](https://github.com/ReactiveX/RxJava/wiki/How-To-Use-RxJava) file with java 8 version. + +#### Other changes + + - [Pull 6313](https://github.com/ReactiveX/RxJava/pull/6313): Adding `@NonNull` annotation factory methods. + - [Pull 6335](https://github.com/ReactiveX/RxJava/pull/6335): Replace indexed loop with for-each java5 syntax. + ### Version 2.2.4 - November 23, 2018 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex.rxjava2%7Crxjava%7C2.2.4%7C)) #### API changes diff --git a/DESIGN.md b/DESIGN.md index 53f828186a..5480b39948 100644 --- a/DESIGN.md +++ b/DESIGN.md @@ -528,13 +528,13 @@ interface ScalarCallable extends java.util.Callable { `ScalarCallable` is also `Callable` and thus its value can be extracted practically anytime. For convenience (and for sense), `ScalarCallable` overrides and hides the superclass' `throws Exception` clause - throwing during assembly time is likely unreasonable for scalars. -Since Reactive-Streams doesn't allow `null`s in the value flow, we have the opportunity to define `ScalarCallable`s and `Callable`s returning `null` should be considered as an empty source - allowing operators to dispatch on the type `Callable` first then branch on the nullness of `call()`. +Since Reactive Streams doesn't allow `null`s in the value flow, we have the opportunity to define `ScalarCallable`s and `Callable`s returning `null` should be considered as an empty source - allowing operators to dispatch on the type `Callable` first then branch on the nullness of `call()`. Interoperating with other libraries, at this level is possible. Reactor-Core uses the same pattern and the two libraries can work with each other's `Publisher+Callable` types. Unfortunately, this means subscription-time only fusion as `ScalarCallable`s live locally in each library. ##### Micro-fusion -Micro-fusion goes a step deeper and tries to reuse internal structures, mostly queues, in operator pairs, saving on allocation and sometimes on atomic operations. It's property is that, in a way, subverts the standard Reactive-Streams protocol between subsequent operators that both support fusion. However, from the outside world's view, they still work according to the RS protocol. +Micro-fusion goes a step deeper and tries to reuse internal structures, mostly queues, in operator pairs, saving on allocation and sometimes on atomic operations. It's property is that, in a way, subverts the standard Reactive Streams protocol between subsequent operators that both support fusion. However, from the outside world's view, they still work according to the RS protocol. Currently, two main kinds of micro-fusion opportunities are available. diff --git a/README.md b/README.md index 3fcaf292d2..1cd82b7f63 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,13 @@ # RxJava: Reactive Extensions for the JVM +## End-of-Life notice + +As of February 28, 2021, The RxJava 2.x branch and version is end-of-life (EOL). No further development, bugfixes, documentation changes, PRs, releases or maintenance will be performed by the project on the 2.x line. + +Users are encouraged to migrate to [3.x](https://github.com/ReactiveX/RxJava) which is currently the only official RxJava version being managed. + +---- + [![codecov.io](http://codecov.io/github/ReactiveX/RxJava/coverage.svg?branch=2.x)](https://codecov.io/gh/ReactiveX/RxJava/branch/2.x) [![Maven Central](https://maven-badges.herokuapp.com/maven-central/io.reactivex.rxjava2/rxjava/badge.svg)](https://maven-badges.herokuapp.com/maven-central/io.reactivex.rxjava2/rxjava) @@ -10,7 +18,7 @@ It extends the [observer pattern](http://en.wikipedia.org/wiki/Observer_pattern) #### Version 2.x ([Javadoc](http://reactivex.io/RxJava/2.x/javadoc/)) -- single dependency: [Reactive-Streams](https://github.com/reactive-streams/reactive-streams-jvm) +- single dependency: [Reactive Streams](https://github.com/reactive-streams/reactive-streams-jvm) - continued support for Java 6+ & [Android](https://github.com/ReactiveX/RxAndroid) 2.3+ - performance gains through design changes learned through the 1.x cycle and through [Reactive-Streams-Commons](https://github.com/reactor/reactive-streams-commons) research project. - Java 8 lambda-friendly API @@ -72,7 +80,7 @@ Flowable.just("Hello world") RxJava 2 features several base classes you can discover operators on: - - [`io.reactivex.Flowable`](http://reactivex.io/RxJava/2.x/javadoc/io/reactivex/Flowable.html): 0..N flows, supporting Reactive-Streams and backpressure + - [`io.reactivex.Flowable`](http://reactivex.io/RxJava/2.x/javadoc/io/reactivex/Flowable.html): 0..N flows, supporting Reactive Streams and backpressure - [`io.reactivex.Observable`](http://reactivex.io/RxJava/2.x/javadoc/io/reactivex/Observable.html): 0..N flows, no backpressure, - [`io.reactivex.Single`](http://reactivex.io/RxJava/2.x/javadoc/io/reactivex/Single.html): a flow of exactly 1 item or an error, - [`io.reactivex.Completable`](http://reactivex.io/RxJava/2.x/javadoc/io/reactivex/Completable.html): a flow without items but only a completion or error signal, @@ -258,12 +266,10 @@ Flowable.range(1, 10) ```java Flowable inventorySource = warehouse.getInventoryAsync(); -inventorySource.flatMap(inventoryItem -> - erp.getDemandAsync(inventoryItem.getId()) - .map(demand - -> System.out.println("Item " + inventoryItem.getName() + " has demand " + demand)); - ) - .subscribe(); +inventorySource + .flatMap(inventoryItem -> erp.getDemandAsync(inventoryItem.getId()) + .map(demand -> "Item " + inventoryItem.getName() + " has demand " + demand)) + .subscribe(System.out::println); ``` ### Continuations @@ -369,7 +375,7 @@ Each reactive base class features operators that can perform such conversions, i |----------|----------|------------|--------|-------|-------------| |**Flowable** | | `toObservable` | `first`, `firstOrError`, `single`, `singleOrError`, `last`, `lastOrError`1 | `firstElement`, `singleElement`, `lastElement` | `ignoreElements` | |**Observable**| `toFlowable`2 | | `first`, `firstOrError`, `single`, `singleOrError`, `last`, `lastOrError`1 | `firstElement`, `singleElement`, `lastElement` | `ignoreElements` | -|**Single** | `toFlowable`3 | `toObservable` | | `toMaybe` | `toCompletable` | +|**Single** | `toFlowable`3 | `toObservable` | | `toMaybe` | `ignoreElement` | |**Maybe** | `toFlowable`3 | `toObservable` | `toSingle` | | `ignoreElement` | |**Completable** | `toFlowable` | `toObservable` | `toSingle` | `toMaybe` | | diff --git a/build.gradle b/build.gradle index 2f33e66093..48565d07d0 100644 --- a/build.gradle +++ b/build.gradle @@ -52,7 +52,7 @@ targetCompatibility = JavaVersion.VERSION_1_6 // --------------------------------------- def junitVersion = "4.12" -def reactiveStreamsVersion = "1.0.2" +def reactiveStreamsVersion = "1.0.3" def mockitoVersion = "2.1.0" def jmhLibVersion = "1.20" def testNgVersion = "6.11" diff --git a/docs/Additional-Reading.md b/docs/Additional-Reading.md index b5a4a2604a..d634e956a6 100644 --- a/docs/Additional-Reading.md +++ b/docs/Additional-Reading.md @@ -1,4 +1,4 @@ -(A more complete and up-to-date list of resources can be found at the reactivex.io site: [[http://reactivex.io/tutorials.html]]) +A more complete and up-to-date list of resources can be found at the [reactivex.io site](http://reactivex.io/tutorials.html) # Introducing Reactive Programming * [Introduction to Rx](http://www.introtorx.com/): a free, on-line book by Lee Campbell **(1.x)** @@ -10,7 +10,7 @@ * [Your Mouse is a Database](http://queue.acm.org/detail.cfm?id=2169076) by Erik Meijer * [A Playful Introduction to Rx](https://www.youtube.com/watch?v=WKore-AkisY) a video lecture by Erik Meijer * Wikipedia: [Reactive Programming](http://en.wikipedia.org/wiki/Reactive_programming) and [Functional Reactive Programming](http://en.wikipedia.org/wiki/Functional_reactive_programming) -* [What is Reactive Programming?](http://blog.hackhands.com/overview-of-reactive-programming/) a video presentation by Jafar Husain. +* [What is Reactive Programming?](https://www.youtube.com/watch?v=-8Y1-lE6NSA) a video presentation by Jafar Husain. * [2 minute introduction to Rx](https://medium.com/@andrestaltz/2-minute-introduction-to-rx-24c8ca793877) by André Staltz * StackOverflow: [What is (functional) reactive programming?](http://stackoverflow.com/a/1030631/1946802) * [The Reactive Manifesto](http://www.reactivemanifesto.org/) diff --git a/docs/Alphabetical-List-of-Observable-Operators.md b/docs/Alphabetical-List-of-Observable-Operators.md index 86495638c0..e5728356bc 100644 --- a/docs/Alphabetical-List-of-Observable-Operators.md +++ b/docs/Alphabetical-List-of-Observable-Operators.md @@ -1,250 +1,250 @@ -* **`aggregate( )`** — _see [**`reduce( )`**](Mathematical-and-Aggregate-Operators#reduce)_ -* [**`all( )`**](Conditional-and-Boolean-Operators#all) — determine whether all items emitted by an Observable meet some criteria -* [**`amb( )`**](Conditional-and-Boolean-Operators#amb) — given two or more source Observables, emits all of the items from the first of these Observables to emit an item -* **`ambWith( )`** — _instance version of [**`amb( )`**](Conditional-and-Boolean-Operators#amb)_ -* [**`and( )`**](Combining-Observables#and-then-and-when) — combine the emissions from two or more source Observables into a `Pattern` (`rxjava-joins`) -* **`apply( )`** (scala) — _see [**`create( )`**](Creating-Observables#create)_ -* **`asObservable( )`** (kotlin) — _see [**`from( )`**](Creating-Observables#from) (et al.)_ -* [**`asyncAction( )`**](Async-Operators#toasync-or-asyncaction-or-asyncfunc) — convert an Action into an Observable that executes the Action and emits its return value (`rxjava-async`) -* [**`asyncFunc( )`**](Async-Operators#toasync-or-asyncaction-or-asyncfunc) — convert a function into an Observable that executes the function and emits its return value (`rxjava-async`) -* [**`averageDouble( )`**](Mathematical-and-Aggregate-Operators#averageinteger-averagelong-averagefloat-and-averagedouble) — calculates the average of Doubles emitted by an Observable and emits this average (`rxjava-math`) -* [**`averageFloat( )`**](Mathematical-and-Aggregate-Operators#averageinteger-averagelong-averagefloat-and-averagedouble) — calculates the average of Floats emitted by an Observable and emits this average (`rxjava-math`) -* [**`averageInteger( )`**](Mathematical-and-Aggregate-Operators#averageinteger-averagelong-averagefloat-and-averagedouble) — calculates the average of Integers emitted by an Observable and emits this average (`rxjava-math`) -* [**`averageLong( )`**](Mathematical-and-Aggregate-Operators#averageinteger-averagelong-averagefloat-and-averagedouble) — calculates the average of Longs emitted by an Observable and emits this average (`rxjava-math`) -* **`blocking( )`** (clojure) — _see [**`toBlocking( )`**](Blocking-Observable-Operators)_ -* [**`buffer( )`**](Transforming-Observables#buffer) — periodically gather items from an Observable into bundles and emit these bundles rather than emitting the items one at a time -* [**`byLine( )`**](String-Observables#byline) (`StringObservable`) — converts an Observable of Strings into an Observable of Lines by treating the source sequence as a stream and splitting it on line-endings -* [**`cache( )`**](Observable-Utility-Operators#cache) — remember the sequence of items emitted by the Observable and emit the same sequence to future Subscribers -* [**`cast( )`**](Transforming-Observables#cast) — cast all items from the source Observable into a particular type before reemitting them -* **`catch( )`** (clojure) — _see [**`onErrorResumeNext( )`**](Error-Handling-Operators#onerrorresumenext)_ -* [**`chunkify( )`**](Phantom-Operators#chunkify) — returns an iterable that periodically returns a list of items emitted by the source Observable since the last list (⁇) -* [**`collect( )`**](Mathematical-and-Aggregate-Operators#collect) — collects items emitted by the source Observable into a single mutable data structure and returns an Observable that emits this structure -* [**`combineLatest( )`**](Combining-Observables#combinelatest) — when an item is emitted by either of two Observables, combine the latest item emitted by each Observable via a specified function and emit items based on the results of this function -* **`combineLatestWith( )`** (scala) — _instance version of [**`combineLatest( )`**](Combining-Observables#combinelatest)_ -* [**`concat( )`**](Mathematical-and-Aggregate-Operators#concat) — concatenate two or more Observables sequentially -* [**`concatMap( )`**](Transforming-Observables#flatmap-concatmap-and-flatmapiterable) — transform the items emitted by an Observable into Observables, then flatten this into a single Observable, without interleaving -* **`concatWith( )`** — _instance version of [**`concat( )`**](Mathematical-and-Aggregate-Operators#concat)_ -* [**`connect( )`**](Connectable-Observable-Operators#connectableobservableconnect) — instructs a Connectable Observable to begin emitting items -* **`cons( )`** (clojure) — _see [**`concat( )`**](Mathematical-and-Aggregate-Operators#concat)_ -* [**`contains( )`**](Conditional-and-Boolean-Operators#contains) — determine whether an Observable emits a particular item or not -* [**`count( )`**](Mathematical-and-Aggregate-Operators#count-and-countlong) — counts the number of items emitted by an Observable and emits this count -* [**`countLong( )`**](Mathematical-and-Aggregate-Operators#count-and-countlong) — counts the number of items emitted by an Observable and emits this count -* [**`create( )`**](Creating-Observables#create) — create an Observable from scratch by means of a function -* **`cycle( )`** (clojure) — _see [**`repeat( )`**](Creating-Observables#repeat)_ -* [**`debounce( )`**](Filtering-Observables#throttlewithtimeout-or-debounce) — only emit an item from the source Observable after a particular timespan has passed without the Observable emitting any other items -* [**`decode( )`**](String-Observables#decode) (`StringObservable`) — convert a stream of multibyte characters into an Observable that emits byte arrays that respect character boundaries -* [**`defaultIfEmpty( )`**](Conditional-and-Boolean-Operators#defaultifempty) — emit items from the source Observable, or emit a default item if the source Observable completes after emitting no items -* [**`defer( )`**](Creating-Observables#defer) — do not create the Observable until a Subscriber subscribes; create a fresh Observable on each subscription -* [**`deferFuture( )`**](Async-Operators#deferfuture) — convert a Future that returns an Observable into an Observable, but do not attempt to get the Observable that the Future returns until a Subscriber subscribes (`rxjava-async`) -* [**`deferCancellableFuture( )`**](Phantom-Operators#fromcancellablefuture-startcancellablefuture-and-defercancellablefuture-) — convert a Future that returns an Observable into an Observable in a way that monitors the subscription status of the Observable to determine whether to halt work on the Future, but do not attempt to get the returned Observable until a Subscriber subscribes (⁇)(`rxjava-async`) -* [**`delay( )`**](Observable-Utility-Operators#delay) — shift the emissions from an Observable forward in time by a specified amount -* [**`dematerialize( )`**](Observable-Utility-Operators#dematerialize) — convert a materialized Observable back into its non-materialized form -* [**`distinct( )`**](Filtering-Observables#distinct) — suppress duplicate items emitted by the source Observable -* [**`distinctUntilChanged( )`**](Filtering-Observables#distinctuntilchanged) — suppress duplicate consecutive items emitted by the source Observable -* **`do( )`** (clojure) — _see [**`doOnEach( )`**](Observable-Utility-Operators#dooneach)_ -* [**`doOnCompleted( )`**](Observable-Utility-Operators#dooncompleted) — register an action to take when an Observable completes successfully -* [**`doOnEach( )`**](Observable-Utility-Operators#dooneach) — register an action to take whenever an Observable emits an item -* [**`doOnError( )`**](Observable-Utility-Operators#doonerror) — register an action to take when an Observable completes with an error -* **`doOnNext( )`** — _see [**`doOnEach( )`**](Observable-Utility-Operators#dooneach)_ +* **`aggregate( )`** — _see [**`reduce( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#reduce)_ +* [**`all( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#boolean-operators) — determine whether all items emitted by an Observable meet some criteria +* [**`amb( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#conditional-operators) — given two or more source Observables, emits all of the items from the first of these Observables to emit an item +* **`ambWith( )`** — _instance version of [**`amb( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#conditional-operators)_ +* [**`and( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#and-then-and-when) — combine the emissions from two or more source Observables into a `Pattern` (`rxjava-joins`) +* **`apply( )`** (scala) — _see [**`create( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables#create)_ +* **`asObservable( )`** (kotlin) — _see [**`from( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables#from) (et al.)_ +* [**`asyncAction( )`**](https://github.com/ReactiveX/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc) — convert an Action into an Observable that executes the Action and emits its return value (`rxjava-async`) +* [**`asyncFunc( )`**](https://github.com/ReactiveX/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc) — convert a function into an Observable that executes the function and emits its return value (`rxjava-async`) +* [**`averageDouble( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#averagedouble) — calculates the average of Doubles emitted by an Observable and emits this average (`rxjava-math`) +* [**`averageFloat( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#averagefloat) — calculates the average of Floats emitted by an Observable and emits this average (`rxjava-math`) +* [**`averageInteger( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators) — calculates the average of Integers emitted by an Observable and emits this average (`rxjava-math`) +* [**`averageLong( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators) — calculates the average of Longs emitted by an Observable and emits this average (`rxjava-math`) +* **`blocking( )`** (clojure) — _see [**`toBlocking( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators)_ +* [**`buffer( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#buffer) — periodically gather items from an Observable into bundles and emit these bundles rather than emitting the items one at a time +* [**`byLine( )`**](https://github.com/ReactiveX/RxJava/wiki/String-Observables) (`StringObservable`) — converts an Observable of Strings into an Observable of Lines by treating the source sequence as a stream and splitting it on line-endings +* [**`cache( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) — remember the sequence of items emitted by the Observable and emit the same sequence to future Subscribers +* [**`cast( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#cast) — cast all items from the source Observable into a particular type before reemitting them +* **`catch( )`** (clojure) — _see [**`onErrorResumeNext( )`**](https://github.com/ReactiveX/RxJava/wiki/Error-Handling-Operators#onerrorresumenext)_ +* [**`chunkify( )`**](https://github.com/ReactiveX/RxJava/wiki/Phantom-Operators#chunkify) — returns an iterable that periodically returns a list of items emitted by the source Observable since the last list (⁇) +* [**`collect( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#collect) — collects items emitted by the source Observable into a single mutable data structure and returns an Observable that emits this structure +* [**`combineLatest( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#combinelatest) — when an item is emitted by either of two Observables, combine the latest item emitted by each Observable via a specified function and emit items based on the results of this function +* **`combineLatestWith( )`** (scala) — _instance version of [**`combineLatest( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#combinelatest)_ +* [**`concat( )`**](http://reactivex.io/documentation/operators/concat.html) — concatenate two or more Observables sequentially +* [**`concatMap( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#concatmap) — transform the items emitted by an Observable into Observables, then flatten this into a single Observable, without interleaving +* **`concatWith( )`** — _instance version of [**`concat( )`**](http://reactivex.io/documentation/operators/concat.html)_ +* [**`connect( )`**](https://github.com/ReactiveX/RxJava/wiki/Connectable-Observable-Operators) — instructs a Connectable Observable to begin emitting items +* **`cons( )`** (clojure) — _see [**`concat( )`**](http://reactivex.io/documentation/operators/concat.html)_ +* [**`contains( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#boolean-operators) — determine whether an Observable emits a particular item or not +* [**`count( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#count) — counts the number of items emitted by an Observable and emits this count +* [**`countLong( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#count) — counts the number of items emitted by an Observable and emits this count +* [**`create( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables#create) — create an Observable from scratch by means of a function +* **`cycle( )`** (clojure) — _see [**`repeat( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables)_ +* [**`debounce( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#debounce) — only emit an item from the source Observable after a particular timespan has passed without the Observable emitting any other items +* [**`decode( )`**](https://github.com/ReactiveX/RxJava/wiki/String-Observables) (`StringObservable`) — convert a stream of multibyte characters into an Observable that emits byte arrays that respect character boundaries +* [**`defaultIfEmpty( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#conditional-operators) — emit items from the source Observable, or emit a default item if the source Observable completes after emitting no items +* [**`defer( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables#defer) — do not create the Observable until a Subscriber subscribes; create a fresh Observable on each subscription +* [**`deferFuture( )`**](https://github.com/ReactiveX/RxJava/wiki/Async-Operators) — convert a Future that returns an Observable into an Observable, but do not attempt to get the Observable that the Future returns until a Subscriber subscribes (`rxjava-async`) +* [**`deferCancellableFuture( )`**](https://github.com/ReactiveX/RxJava/wiki/Phantom-Operators#fromcancellablefuture-startcancellablefuture-and-defercancellablefuture) — convert a Future that returns an Observable into an Observable in a way that monitors the subscription status of the Observable to determine whether to halt work on the Future, but do not attempt to get the returned Observable until a Subscriber subscribes (⁇)(`rxjava-async`) +* [**`delay( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) — shift the emissions from an Observable forward in time by a specified amount +* [**`dematerialize( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) — convert a materialized Observable back into its non-materialized form +* [**`distinct( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#distinct) — suppress duplicate items emitted by the source Observable +* [**`distinctUntilChanged( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#distinctuntilchanged) — suppress duplicate consecutive items emitted by the source Observable +* **`do( )`** (clojure) — _see [**`doOnEach( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators)_ +* [**`doOnCompleted( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) — register an action to take when an Observable completes successfully +* [**`doOnEach( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) — register an action to take whenever an Observable emits an item +* [**`doOnError( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) — register an action to take when an Observable completes with an error +* **`doOnNext( )`** — _see [**`doOnEach( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators)_ * **`doOnRequest( )`** — register an action to take when items are requested from an Observable via reactive-pull backpressure (⁇) -* [**`doOnSubscribe( )`**](Observable-Utility-Operators#doonsubscribe) — register an action to take when an observer subscribes to an Observable -* [**`doOnTerminate( )`**](Observable-Utility-Operators#doonterminate) — register an action to take when an Observable completes, either successfully or with an error -* [**`doOnUnsubscribe( )`**](Observable-Utility-Operators#doonunsubscribe) — register an action to take when an observer unsubscribes from an Observable -* [**`doWhile( )`**](Conditional-and-Boolean-Operators#dowhile) — emit the source Observable's sequence, and then repeat the sequence as long as a condition remains true (`contrib-computation-expressions`) -* **`drop( )`** (scala/clojure) — _see [**`skip( )`**](Filtering-Observables#skip)_ -* **`dropRight( )`** (scala) — _see [**`skipLast( )`**](Filtering-Observables#skiplast)_ -* **`dropUntil( )`** (scala) — _see [**`skipUntil( )`**](Conditional-and-Boolean-Operators#skipuntil)_ -* **`dropWhile( )`** (scala) — _see [**`skipWhile( )`**](Conditional-and-Boolean-Operators#skipwhile)_ -* **`drop-while( )`** (clojure) — _see [**`skipWhile( )`**](Conditional-and-Boolean-Operators#skipwhile)_ -* [**`elementAt( )`**](Filtering-Observables#elementat) — emit item _n_ emitted by the source Observable -* [**`elementAtOrDefault( )`**](Filtering-Observables#elementatordefault) — emit item _n_ emitted by the source Observable, or a default item if the source Observable emits fewer than _n_ items -* [**`empty( )`**](Creating-Observables#empty-error-and-never) — create an Observable that emits nothing and then completes -* [**`encode( )`**](String-Observables#encode) (`StringObservable`) — transform an Observable that emits strings into an Observable that emits byte arrays that respect character boundaries of multibyte characters in the original strings -* [**`error( )`**](Creating-Observables#empty-error-and-never) — create an Observable that emits nothing and then signals an error -* **`every( )`** (clojure) — _see [**`all( )`**](Conditional-and-Boolean-Operators#all)_ -* [**`exists( )`**](Conditional-and-Boolean-Operators#exists-and-isempty) — determine whether an Observable emits any items or not -* [**`filter( )`**](Filtering-Observables#filter) — filter items emitted by an Observable -* **`finally( )`** (clojure) — _see [**`finallyDo( )`**](Observable-Utility-Operators#finallydo)_ -* **`filterNot( )`** (scala) — _see [**`filter( )`**](Filtering-Observables#filter)_ -* [**`finallyDo( )`**](Observable-Utility-Operators#finallydo) — register an action to take when an Observable completes -* [**`first( )`**](Filtering-Observables#first-and-takefirst) (`Observable`) — emit only the first item emitted by an Observable, or the first item that meets some condition -* [**`first( )`**](Blocking-Observable-Operators#first-and-firstordefault) (`BlockingObservable`) — emit only the first item emitted by an Observable, or the first item that meets some condition -* [**`firstOrDefault( )`**](Filtering-Observables#firstordefault) (`Observable`) — emit only the first item emitted by an Observable, or the first item that meets some condition, or a default value if the source Observable is empty -* [**`firstOrDefault( )`**](Blocking-Observable-Operators#first-and-firstordefault) (`BlockingObservable`) — emit only the first item emitted by an Observable, or the first item that meets some condition, or a default value if the source Observable is empty -* **`firstOrElse( )`** (scala) — _see [**`firstOrDefault( )`**](Filtering-Observables#firstordefault) or [**`firstOrDefault( )`**](Blocking-Observable-Operators#first-and-firstordefault) (`BlockingObservable`)_ -* [**`flatMap( )`**](Transforming-Observables#flatmap-concatmap-and-flatmapiterable) — transform the items emitted by an Observable into Observables, then flatten this into a single Observable -* [**`flatMapIterable( )`**](Transforming-Observables#flatmap-concatmap-and-flatmapiterable) — create Iterables corresponding to each emission from a source Observable and merge the results into a single Observable -* **`flatMapIterableWith( )`** (scala) — _instance version of [**`flatMapIterable( )`**](Transforming-Observables#flatmap-concatmap-and-flatmapiterable)_ -* **`flatMapWith( )`** (scala) — _instance version of [**`flatmap( )`**](Transforming-Observables#flatmap-concatmap-and-flatmapiterable)_ -* **`flatten( )`** (scala) — _see [**`merge( )`**](Combining-Observables#merge)_ -* **`flattenDelayError( )`** (scala) — _see [**`mergeDelayError( )`**](Combining-Observables#mergedelayerror)_ -* **`foldLeft( )`** (scala) — _see [**`reduce( )`**](Mathematical-and-Aggregate-Operators#reduce)_ -* **`forall( )`** (scala) — _see [**`all( )`**](Conditional-and-Boolean-Operators#all)_ -* **`forEach( )`** (`Observable`) — _see [**`subscribe( )`**](Observable#onnext-oncompleted-and-onerror)_ -* [**`forEach( )`**](Blocking-Observable-Operators#foreach) (`BlockingObservable`) — invoke a function on each item emitted by the Observable; block until the Observable completes -* [**`forEachFuture( )`**](Async-Operators#foreachfuture) (`Async`) — pass Subscriber methods to an Observable but also have it behave like a Future that blocks until it completes (`rxjava-async`) -* [**`forEachFuture( )`**](Phantom-Operators#foreachfuture) (`BlockingObservable`)— create a futureTask that will invoke a specified function on each item emitted by an Observable (⁇) -* [**`forIterable( )`**](Phantom-Operators#foriterable) — apply a function to the elements of an Iterable to create Observables which are then concatenated (⁇) -* [**`from( )`**](Creating-Observables#from) — convert an Iterable, a Future, or an Array into an Observable -* [**`from( )`**](String-Observables#from) (`StringObservable`) — convert a stream of characters or a Reader into an Observable that emits byte arrays or Strings -* [**`fromAction( )`**](Async-Operators#fromaction) — convert an Action into an Observable that invokes the action and emits its result when a Subscriber subscribes (`rxjava-async`) -* [**`fromCallable( )`**](Async-Operators#fromcallable) — convert a Callable into an Observable that invokes the callable and emits its result or exception when a Subscriber subscribes (`rxjava-async`) -* [**`fromCancellableFuture( )`**](Phantom-Operators#fromcancellablefuture-startcancellablefuture-and-defercancellablefuture-) — convert a Future into an Observable in a way that monitors the subscription status of the Observable to determine whether to halt work on the Future, but do not attempt to get the Future's value until a Subscriber subscribes (⁇)(`rxjava-async`) -* **`fromFunc0( )`** — _see [**`fromCallable( )`**](Async-Operators#fromcallable) (`rxjava-async`)_ -* [**`fromFuture( )`**](Phantom-Operators#fromfuture) — convert a Future into an Observable, but do not attempt to get the Future's value until a Subscriber subscribes (⁇) -* [**`fromRunnable( )`**](Async-Operators#fromrunnable) — convert a Runnable into an Observable that invokes the runable and emits its result when a Subscriber subscribes (`rxjava-async`) -* [**`generate( )`**](Phantom-Operators#generate-and-generateabsolutetime) — create an Observable that emits a sequence of items as generated by a function of your choosing (⁇) -* [**`generateAbsoluteTime( )`**](Phantom-Operators#generate-and-generateabsolutetime) — create an Observable that emits a sequence of items as generated by a function of your choosing, with each item emitted at an item-specific time (⁇) -* **`generator( )`** (clojure) — _see [**`generate( )`**](Phantom-Operators#generate-and-generateabsolutetime)_ -* [**`getIterator( )`**](Blocking-Observable-Operators#transformations-tofuture-toiterable-and-getiterator) — convert the sequence emitted by the Observable into an Iterator -* [**`groupBy( )`**](Transforming-Observables#groupby) — divide an Observable into a set of Observables that emit groups of items from the original Observable, organized by key -* **`group-by( )`** (clojure) — _see [**`groupBy( )`**](Transforming-Observables#groupby)_ -* [**`groupByUntil( )`**](Phantom-Operators#groupbyuntil) — a variant of the [`groupBy( )`](Transforming-Observables#groupby) operator that closes any open GroupedObservable upon a signal from another Observable (⁇) -* [**`groupJoin( )`**](Combining-Observables#join-and-groupjoin) — combine the items emitted by two Observables whenever one item from one Observable falls within a window of duration specified by an item emitted by the other Observable -* **`head( )`** (scala) — _see [**`first( )`**](Blocking-Observable-Operators#first-and-firstordefault) (`BlockingObservable`)_ -* **`headOption( )`** (scala) — _see [**`firstOrDefault( )`**](Filtering-Observables#firstordefault) or [**`firstOrDefault( )`**](Blocking-Observable-Operators#first-and-firstordefault) (`BlockingObservable`)_ -* **`headOrElse( )`** (scala) — _see [**`firstOrDefault( )`**](Filtering-Observables#firstordefault) or [**`firstOrDefault( )`**](Blocking-Observable-Operators#first-and-firstordefault) (`BlockingObservable`)_ -* [**`ifThen( )`**](Conditional-and-Boolean-Operators#ifthen) — only emit the source Observable's sequence if a condition is true, otherwise emit an empty or default sequence (`contrib-computation-expressions`) -* [**`ignoreElements( )`**](Filtering-Observables#ignoreelements) — discard the items emitted by the source Observable and only pass through the error or completed notification -* [**`interval( )`**](Creating-Observables#interval) — create an Observable that emits a sequence of integers spaced by a given time interval -* **`into( )`** (clojure) — _see [**`reduce( )`**](Mathematical-and-Aggregate-Operators#reduce)_ -* [**`isEmpty( )`**](Conditional-and-Boolean-Operators#exists-and-isempty) — determine whether an Observable emits any items or not -* **`items( )`** (scala) — _see [**`just( )`**](Creating-Observables#just)_ -* [**`join( )`**](Combining-Observables#join-and-groupjoin) — combine the items emitted by two Observables whenever one item from one Observable falls within a window of duration specified by an item emitted by the other Observable -* [**`join( )`**](String-Observables#join) (`StringObservable`) — converts an Observable that emits a sequence of strings into an Observable that emits a single string that concatenates them all, separating them by a specified string -* [**`just( )`**](Creating-Observables#just) — convert an object into an Observable that emits that object -* [**`last( )`**](Blocking-Observable-Operators#last-and-lastordefault) (`BlockingObservable`) — block until the Observable completes, then return the last item emitted by the Observable -* [**`last( )`**](Filtering-Observables#last) (`Observable`) — emit only the last item emitted by the source Observable -* **`lastOption( )`** (scala) — _see [**`lastOrDefault( )`**](Filtering-Observables#lastOrDefault) or [**`lastOrDefault( )`**](Blocking-Observable-Operators#last-and-lastordefault) (`BlockingObservable`)_ -* [**`lastOrDefault( )`**](Blocking-Observable-Operators#last-and-lastordefault) (`BlockingObservable`) — block until the Observable completes, then return the last item emitted by the Observable or a default item if there is no last item -* [**`lastOrDefault( )`**](Filtering-Observables#lastOrDefault) (`Observable`) — emit only the last item emitted by an Observable, or a default value if the source Observable is empty -* **`lastOrElse( )`** (scala) — _see [**`lastOrDefault( )`**](Filtering-Observables#lastOrDefault) or [**`lastOrDefault( )`**](Blocking-Observable-Operators#last-and-lastordefault) (`BlockingObservable`)_ -* [**`latest( )`**](Blocking-Observable-Operators#latest) — returns an iterable that blocks until or unless the Observable emits an item that has not been returned by the iterable, then returns the latest such item -* **`length( )`** (scala) — _see [**`count( )`**](Mathematical-and-Aggregate-Operators#count-and-countlong)_ -* **`limit( )`** — _see [**`take( )`**](Filtering-Observables#take)_ -* **`longCount( )`** (scala) — _see [**`countLong( )`**](Mathematical-and-Aggregate-Operators#count-and-countlong)_ -* [**`map( )`**](Transforming-Observables#map) — transform the items emitted by an Observable by applying a function to each of them -* **`mapcat( )`** (clojure) — _see [**`concatMap( )`**](Transforming-Observables#flatmap-concatmap-and-flatmapiterable)_ -* **`mapMany( )`** — _see: [**`flatMap( )`**](Transforming-Observables#flatmap-concatmap-and-flatmapiterable)_ -* [**`materialize( )`**](Observable-Utility-Operators#materialize) — convert an Observable into a list of Notifications -* [**`max( )`**](Mathematical-and-Aggregate-Operators#max) — emits the maximum value emitted by a source Observable (`rxjava-math`) -* [**`maxBy( )`**](Mathematical-and-Aggregate-Operators#maxby) — emits the item emitted by the source Observable that has the maximum key value (`rxjava-math`) -* [**`merge( )`**](Combining-Observables#merge) — combine multiple Observables into one -* [**`mergeDelayError( )`**](Combining-Observables#mergedelayerror) — combine multiple Observables into one, allowing error-free Observables to continue before propagating errors -* **`merge-delay-error( )`** (clojure) — _see [**`mergeDelayError( )`**](Combining-Observables#mergedelayerror)_ -* **`mergeMap( )`** * — _see: [**`flatMap( )`**](Transforming-Observables#flatmap-concatmap-and-flatmapiterable)_ -* **`mergeMapIterable( )`** — _see: [**`flatMapIterable( )`**](Transforming-Observables#flatmap-concatmap-and-flatmapiterable)_ -* **`mergeWith( )`** — _instance version of [**`merge( )`**](Combining-Observables#merge)_ -* [**`min( )`**](Mathematical-and-Aggregate-Operators#min) — emits the minimum value emitted by a source Observable (`rxjava-math`) -* [**`minBy( )`**](Mathematical-and-Aggregate-Operators#minby) — emits the item emitted by the source Observable that has the minimum key value (`rxjava-math`) -* [**`mostRecent( )`**](Blocking-Observable-Operators#mostrecent) — returns an iterable that always returns the item most recently emitted by the Observable -* [**`multicast( )`**](Phantom-Operators#multicast) — represents an Observable as a Connectable Observable -* [**`never( )`**](Creating-Observables#empty-error-and-never) — create an Observable that emits nothing at all -* [**`next( )`**](Blocking-Observable-Operators#next) — returns an iterable that blocks until the Observable emits another item, then returns that item -* **`nonEmpty( )`** (scala) — _see [**`isEmpty( )`**](Conditional-and-Boolean-Operators#exists-and-isempty)_ -* **`nth( )`** (clojure) — _see [**`elementAt( )`**](Filtering-Observables#elementat) and [**`elementAtOrDefault( )`**](Filtering-Observables#elementatordefault)_ -* [**`observeOn( )`**](Observable-Utility-Operators#observeon) — specify on which Scheduler a Subscriber should observe the Observable -* [**`ofType( )`**](Filtering-Observables#oftype) — emit only those items from the source Observable that are of a particular class -* [**`onBackpressureBlock( )`**](Backpressure) — block the Observable's thread until the Observer is ready to accept more items from the Observable (⁇) -* [**`onBackpressureBuffer( )`**](Backpressure) — maintain a buffer of all emissions from the source Observable and emit them to downstream Subscribers according to the requests they generate -* [**`onBackpressureDrop( )`**](Backpressure) — drop emissions from the source Observable unless there is a pending request from a downstream Subscriber, in which case emit enough items to fulfill the request -* [**`onErrorFlatMap( )`**](Phantom-Operators#onerrorflatmap) — instructs an Observable to emit a sequence of items whenever it encounters an error (⁇) -* [**`onErrorResumeNext( )`**](Error-Handling-Operators#onerrorresumenext) — instructs an Observable to emit a sequence of items if it encounters an error -* [**`onErrorReturn( )`**](Error-Handling-Operators#onerrorreturn) — instructs an Observable to emit a particular item when it encounters an error -* [**`onExceptionResumeNext( )`**](Error-Handling-Operators#onexceptionresumenext) — instructs an Observable to continue emitting items after it encounters an exception (but not another variety of throwable) -* **`orElse( )`** (scala) — _see [**`defaultIfEmpty( )`**](Conditional-and-Boolean-Operators#defaultifempty)_ -* [**`parallel( )`**](Phantom-Operators#parallel) — split the work done on the emissions from an Observable into multiple Observables each operating on its own parallel thread (⁇) -* [**`parallelMerge( )`**](Phantom-Operators#parallelmerge) — combine multiple Observables into smaller number of Observables (⁇) -* [**`pivot( )`**](Phantom-Operators#pivot) — combine multiple sets of grouped observables so that they are arranged primarily by group rather than by set (⁇) -* [**`publish( )`**](Connectable-Observable-Operators#observablepublish) — represents an Observable as a Connectable Observable -* [**`publishLast( )`**](Phantom-Operators#publishlast) — represent an Observable as a Connectable Observable that emits only the last item emitted by the source Observable (⁇) -* [**`range( )`**](Creating-Observables#range) — create an Observable that emits a range of sequential integers -* [**`reduce( )`**](Mathematical-and-Aggregate-Operators#reduce) — apply a function to each emitted item, sequentially, and emit only the final accumulated value -* **`reductions( )`** (clojure) — _see [**`scan( )`**](Transforming-Observables#scan)_ -* [**`refCount( )`**](Connectable-Observable-Operators#connectableobservablerefcount) — makes a Connectable Observable behave like an ordinary Observable -* [**`repeat( )`**](Creating-Observables#repeat) — create an Observable that emits a particular item or sequence of items repeatedly -* [**`repeatWhen( )`**](Creating-Observables#repeatwhen) — create an Observable that emits a particular item or sequence of items repeatedly, depending on the emissions of a second Observable -* [**`replay( )`**](Connectable-Observable-Operators#observablereplay) — ensures that all Subscribers see the same sequence of emitted items, even if they subscribe after the Observable begins emitting the items -* **`rest( )`** (clojure) — _see [**`next( )`**](Blocking-Observable-Operators#next)_ -* **`return( )`** (clojure) — _see [**`just( )`**](Creating-Observables#just)_ -* [**`retry( )`**](Error-Handling-Operators#retry) — if a source Observable emits an error, resubscribe to it in the hopes that it will complete without error -* [**`retrywhen( )`**](Error-Handling-Operators#retrywhen) — if a source Observable emits an error, pass that error to another Observable to determine whether to resubscribe to the source -* [**`runAsync( )`**](Async-Operators#runasync) — returns a `StoppableObservable` that emits multiple actions as generated by a specified Action on a Scheduler (`rxjava-async`) -* [**`sample( )`**](Filtering-Observables#sample-or-throttlelast) — emit the most recent items emitted by an Observable within periodic time intervals -* [**`scan( )`**](Transforming-Observables#scan) — apply a function to each item emitted by an Observable, sequentially, and emit each successive value -* **`seq( )`** (clojure) — _see [**`getIterator( )`**](Blocking-Observable-Operators#transformations-tofuture-toiterable-and-getiterator)_ -* [**`sequenceEqual( )`**](Conditional-and-Boolean-Operators#sequenceequal) — test the equality of sequences emitted by two Observables -* **`sequenceEqualWith( )`** (scala) — _instance version of [**`sequenceEqual( )`**](Conditional-and-Boolean-Operators#sequenceequal)_ -* [**`serialize( )`**](Observable-Utility-Operators#serialize) — force an Observable to make serialized calls and to be well-behaved -* **`share( )`** — _see [**`refCount( )`**](Connectable-Observable-Operators#connectableobservablerefcount)_ -* [**`single( )`**](Blocking-Observable-Operators#single-and-singleordefault) (`BlockingObservable`) — if the source Observable completes after emitting a single item, return that item, otherwise throw an exception -* [**`single( )`**](Observable-Utility-Operators#single-and-singleordefault) (`Observable`) — if the source Observable completes after emitting a single item, emit that item, otherwise notify of an exception -* **`singleOption( )`** (scala) — _see [**`singleOrDefault( )`**](Blocking-Observable-Operators#single-and-singleordefault) (`BlockingObservable`)_ -* [**`singleOrDefault( )`**](Blocking-Observable-Operators#single-and-singleordefault) (`BlockingObservable`) — if the source Observable completes after emitting a single item, return that item, otherwise return a default item -* [**`singleOrDefault( )`**](Observable-Utility-Operators#single-and-singleordefault) (`Observable`) — if the source Observable completes after emitting a single item, emit that item, otherwise emit a default item -* **`singleOrElse( )`** (scala) — _see [**`singleOrDefault( )`**](Observable-Utility-Operators#single-and-singleordefault)_ -* **`size( )`** (scala) — _see [**`count( )`**](Mathematical-and-Aggregate-Operators#count-and-countlong)_ -* [**`skip( )`**](Filtering-Observables#skip) — ignore the first _n_ items emitted by an Observable -* [**`skipLast( )`**](Filtering-Observables#skiplast) — ignore the last _n_ items emitted by an Observable -* [**`skipUntil( )`**](Conditional-and-Boolean-Operators#skipuntil) — discard items emitted by a source Observable until a second Observable emits an item, then emit the remainder of the source Observable's items -* [**`skipWhile( )`**](Conditional-and-Boolean-Operators#skipwhile) — discard items emitted by an Observable until a specified condition is false, then emit the remainder -* **`sliding( )`** (scala) — _see [**`window( )`**](Transforming-Observables#window)_ -* **`slidingBuffer( )`** (scala) — _see [**`buffer( )`**](Transforming-Observables#buffer)_ -* [**`split( )`**](String-Observables#split) (`StringObservable`) — converts an Observable of Strings into an Observable of Strings that treats the source sequence as a stream and splits it on a specified regex boundary -* [**`start( )`**](Async-Operators#start) — create an Observable that emits the return value of a function (`rxjava-async`) -* [**`startCancellableFuture( )`**](Phantom-Operators#fromcancellablefuture-startcancellablefuture-and-defercancellablefuture-) — convert a function that returns Future into an Observable that emits that Future's return value in a way that monitors the subscription status of the Observable to determine whether to halt work on the Future (⁇)(`rxjava-async`) -* [**`startFuture( )`**](Async-Operators#startfuture) — convert a function that returns Future into an Observable that emits that Future's return value (`rxjava-async`) -* [**`startWith( )`**](Combining-Observables#startwith) — emit a specified sequence of items before beginning to emit the items from the Observable -* [**`stringConcat( )`**](String-Observables#stringconcat) (`StringObservable`) — converts an Observable that emits a sequence of strings into an Observable that emits a single string that concatenates them all -* [**`subscribeOn( )`**](Observable-Utility-Operators#subscribeon) — specify which Scheduler an Observable should use when its subscription is invoked -* [**`sumDouble( )`**](Mathematical-and-Aggregate-Operators#suminteger-sumlong-sumfloat-and-sumdouble) — adds the Doubles emitted by an Observable and emits this sum (`rxjava-math`) -* [**`sumFloat( )`**](Mathematical-and-Aggregate-Operators#suminteger-sumlong-sumfloat-and-sumdouble) — adds the Floats emitted by an Observable and emits this sum (`rxjava-math`) -* [**`sumInteger( )`**](Mathematical-and-Aggregate-Operators#suminteger-sumlong-sumfloat-and-sumdouble) — adds the Integers emitted by an Observable and emits this sum (`rxjava-math`) -* [**`sumLong( )`**](Mathematical-and-Aggregate-Operators#suminteger-sumlong-sumfloat-and-sumdouble) — adds the Longs emitted by an Observable and emits this sum (`rxjava-math`) -* **`switch( )`** (scala) — _see [**`switchOnNext( )`**](Combining-Observables#switchonnext)_ -* [**`switchCase( )`**](Conditional-and-Boolean-Operators#switchcase) — emit the sequence from a particular Observable based on the results of an evaluation (`contrib-computation-expressions`) -* [**`switchMap( )`**](Transforming-Observables#switchmap) — transform the items emitted by an Observable into Observables, and mirror those items emitted by the most-recently transformed Observable -* [**`switchOnNext( )`**](Combining-Observables#switchonnext) — convert an Observable that emits Observables into a single Observable that emits the items emitted by the most-recently emitted of those Observables -* **`synchronize( )`** — _see [**`serialize( )`**](Observable-Utility-Operators#serialize)_ -* [**`take( )`**](Filtering-Observables#take) — emit only the first _n_ items emitted by an Observable -* [**`takeFirst( )`**](Filtering-Observables#first-and-takefirst) — emit only the first item emitted by an Observable, or the first item that meets some condition -* [**`takeLast( )`**](Filtering-Observables#takelast) — only emit the last _n_ items emitted by an Observable -* [**`takeLastBuffer( )`**](Filtering-Observables#takelastbuffer) — emit the last _n_ items emitted by an Observable, as a single list item -* **`takeRight( )`** (scala) — _see [**`last( )`**](Filtering-Observables#last) (`Observable`) or [**`takeLast( )`**](Filtering-Observables#takelast)_ -* [**`takeUntil( )`**](Conditional-and-Boolean-Operators#takeuntil) — emits the items from the source Observable until a second Observable emits an item -* [**`takeWhile( )`**](Conditional-and-Boolean-Operators#takewhile) — emit items emitted by an Observable as long as a specified condition is true, then skip the remainder -* **`take-while( )`** (clojure) — _see [**`takeWhile( )`**](Conditional-and-Boolean-Operators#takewhile)_ -* [**`then( )`**](Combining-Observables#and-then-and-when) — transform a series of `Pattern` objects via a `Plan` template (`rxjava-joins`) -* [**`throttleFirst( )`**](Filtering-Observables#throttlefirst) — emit the first items emitted by an Observable within periodic time intervals -* [**`throttleLast( )`**](Filtering-Observables#sample-or-throttlelast) — emit the most recent items emitted by an Observable within periodic time intervals -* [**`throttleWithTimeout( )`**](Filtering-Observables#throttlewithtimeout-or-debounce) — only emit an item from the source Observable after a particular timespan has passed without the Observable emitting any other items -* **`throw( )`** (clojure) — _see [**`error( )`**](Creating-Observables#empty-error-and-never)_ -* [**`timeInterval( )`**](Observable-Utility-Operators#timeinterval) — emit the time lapsed between consecutive emissions of a source Observable -* [**`timeout( )`**](Filtering-Observables#timeout) — emit items from a source Observable, but issue an exception if no item is emitted in a specified timespan -* [**`timer( )`**](Creating-Observables#timer) — create an Observable that emits a single item after a given delay -* [**`timestamp( )`**](Observable-Utility-Operators#timestamp) — attach a timestamp to every item emitted by an Observable -* [**`toAsync( )`**](Async-Operators#toasync-or-asyncaction-or-asyncfunc) — convert a function or Action into an Observable that executes the function and emits its return value (`rxjava-async`) -* [**`toBlocking( )`**](Blocking-Observable-Operators) — transform an Observable into a BlockingObservable -* **`toBlockingObservable( )`** - _see [**`toBlocking( )`**](Blocking-Observable-Operators)_ -* [**`toFuture( )`**](Blocking-Observable-Operators#transformations-tofuture-toiterable-and-getiterator) — convert the Observable into a Future -* [**`toIterable( )`**](Blocking-Observable-Operators#transformations-tofuture-toiterable-and-getiterator) — convert the sequence emitted by the Observable into an Iterable -* **`toIterator( )`** — _see [**`getIterator( )`**](Blocking-Observable-Operators#transformations-tofuture-toiterable-and-getiterator)_ -* [**`toList( )`**](Mathematical-and-Aggregate-Operators#tolist) — collect all items from an Observable and emit them as a single List -* [**`toMap( )`**](Mathematical-and-Aggregate-Operators#tomap-and-tomultimap) — convert the sequence of items emitted by an Observable into a map keyed by a specified key function -* [**`toMultimap( )`**](Mathematical-and-Aggregate-Operators#tomap-and-tomultimap) — convert the sequence of items emitted by an Observable into an ArrayList that is also a map keyed by a specified key function -* **`toSeq( )`** (scala) — _see [**`toList( )`**](Mathematical-and-Aggregate-Operators#tolist)_ -* [**`toSortedList( )`**](Mathematical-and-Aggregate-Operators#tosortedlist) — collect all items from an Observable and emit them as a single, sorted List -* **`tumbling( )`** (scala) — _see [**`window( )`**](Transforming-Observables#window)_ -* **`tumblingBuffer( )`** (scala) — _see [**`buffer( )`**](Transforming-Observables#buffer)_ -* [**`using( )`**](Observable-Utility-Operators#using) — create a disposable resource that has the same lifespan as an Observable -* [**`when( )`**](Combining-Observables#and-then-and-when) — convert a series of `Plan` objects into an Observable (`rxjava-joins`) -* **`where( )`** — _see: [**`filter( )`**](Filtering-Observables#filter)_ -* [**`whileDo( )`**](Conditional-and-Boolean-Operators#whiledo) — if a condition is true, emit the source Observable's sequence and then repeat the sequence as long as the condition remains true (`contrib-computation-expressions`) -* [**`window( )`**](Transforming-Observables#window) — periodically subdivide items from an Observable into Observable windows and emit these windows rather than emitting the items one at a time -* [**`zip( )`**](Combining-Observables#zip) — combine sets of items emitted by two or more Observables together via a specified function and emit items based on the results of this function -* **`zipWith( )`** — _instance version of [**`zip( )`**](Combining-Observables#zip)_ -* **`zipWithIndex( )`** (scala) — _see [**`zip( )`**](Combining-Observables#zip)_ -* **`++`** (scala) — _see [**`concat( )`**](Mathematical-and-Aggregate-Operators#concat)_ -* **`+:`** (scala) — _see [**`startWith( )`**](Combining-Observables#startwith)_ +* [**`doOnSubscribe( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) — register an action to take when an observer subscribes to an Observable +* [**`doOnTerminate( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) — register an action to take when an Observable completes, either successfully or with an error +* [**`doOnUnsubscribe( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) — register an action to take when an observer unsubscribes from an Observable +* [**`doWhile( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators) — emit the source Observable's sequence, and then repeat the sequence as long as a condition remains true (`contrib-computation-expressions`) +* **`drop( )`** (scala/clojure) — _see [**`skip( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#skip)_ +* **`dropRight( )`** (scala) — _see [**`skipLast( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#skiplast)_ +* **`dropUntil( )`** (scala) — _see [**`skipUntil( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators)_ +* **`dropWhile( )`** (scala) — _see [**`skipWhile( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators)_ +* **`drop-while( )`** (clojure) — _see [**`skipWhile( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#skipwhile)_ +* [**`elementAt( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#elementat) — emit item _n_ emitted by the source Observable +* [**`elementAtOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables) — emit item _n_ emitted by the source Observable, or a default item if the source Observable emits fewer than _n_ items +* [**`empty( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables#empty) — create an Observable that emits nothing and then completes +* [**`encode( )`**](https://github.com/ReactiveX/RxJava/wiki/String-Observables) (`StringObservable`) — transform an Observable that emits strings into an Observable that emits byte arrays that respect character boundaries of multibyte characters in the original strings +* [**`error( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables#error) — create an Observable that emits nothing and then signals an error +* **`every( )`** (clojure) — _see [**`all( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#boolean-operators)_ +* [**`exists( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#boolean-operators) — determine whether an Observable emits any items or not +* [**`filter( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#filter) — filter items emitted by an Observable +* **`finally( )`** (clojure) — _see [**`finallyDo( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators)_ +* **`filterNot( )`** (scala) — _see [**`filter( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#filter)_ +* [**`finallyDo( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) — register an action to take when an Observable completes +* [**`first( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#first) (`Observable`) — emit only the first item emitted by an Observable, or the first item that meets some condition +* [**`first( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) (`BlockingObservable`) — emit only the first item emitted by an Observable, or the first item that meets some condition +* [**`firstOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables) (`Observable`) — emit only the first item emitted by an Observable, or the first item that meets some condition, or a default value if the source Observable is empty +* [**`firstOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) (`BlockingObservable`) — emit only the first item emitted by an Observable, or the first item that meets some condition, or a default value if the source Observable is empty +* **`firstOrElse( )`** (scala) — _see [**`firstOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables) or [**`firstOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) (`BlockingObservable`)_ +* [**`flatMap( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#flatmap) — transform the items emitted by an Observable into Observables, then flatten this into a single Observable +* [**`flatMapIterable( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#flatmapiterable) — create Iterables corresponding to each emission from a source Observable and merge the results into a single Observable +* **`flatMapIterableWith( )`** (scala) — _instance version of [**`flatMapIterable( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#flatmapiterable)_ +* **`flatMapWith( )`** (scala) — _instance version of [**`flatmap( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#flatmap)_ +* **`flatten( )`** (scala) — _see [**`merge( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#merge)_ +* **`flattenDelayError( )`** (scala) — _see [**`mergeDelayError( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#mergedelayerror)_ +* **`foldLeft( )`** (scala) — _see [**`reduce( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#reduce)_ +* **`forall( )`** (scala) — _see [**`all( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#boolean-operators)_ +* **`forEach( )`** (`Observable`) — _see [**`subscribe( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable)_ +* [**`forEach( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) (`BlockingObservable`) — invoke a function on each item emitted by the Observable; block until the Observable completes +* [**`forEachFuture( )`**](https://github.com/ReactiveX/RxJava/wiki/Async-Operators) (`Async`) — pass Subscriber methods to an Observable but also have it behave like a Future that blocks until it completes (`rxjava-async`) +* [**`forEachFuture( )`**](https://github.com/ReactiveX/RxJava/wiki/Phantom-Operators#foreachfuture) (`BlockingObservable`)— create a futureTask that will invoke a specified function on each item emitted by an Observable (⁇) +* [**`forIterable( )`**](https://github.com/ReactiveX/RxJava/wiki/Phantom-Operators#foriterable) — apply a function to the elements of an Iterable to create Observables which are then concatenated (⁇) +* [**`from( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables#from) — convert an Iterable, a Future, or an Array into an Observable +* [**`from( )`**](https://github.com/ReactiveX/RxJava/wiki/String-Observables) (`StringObservable`) — convert a stream of characters or a Reader into an Observable that emits byte arrays or Strings +* [**`fromAction( )`**](https://github.com/ReactiveX/RxJava/wiki/Async-Operators) — convert an Action into an Observable that invokes the action and emits its result when a Subscriber subscribes (`rxjava-async`) +* [**`fromCallable( )`**](https://github.com/ReactiveX/RxJava/wiki/Async-Operators) — convert a Callable into an Observable that invokes the callable and emits its result or exception when a Subscriber subscribes (`rxjava-async`) +* [**`fromCancellableFuture( )`**](https://github.com/ReactiveX/RxJava/wiki/Phantom-Operators#fromcancellablefuture-startcancellablefuture-and-defercancellablefuture) — convert a Future into an Observable in a way that monitors the subscription status of the Observable to determine whether to halt work on the Future, but do not attempt to get the Future's value until a Subscriber subscribes (⁇)(`rxjava-async`) +* **`fromFunc0( )`** — _see [**`fromCallable( )`**](https://github.com/ReactiveX/RxJava/wiki/Async-Operators) (`rxjava-async`)_ +* [**`fromFuture( )`**](https://github.com/ReactiveX/RxJava/wiki/Phantom-Operators#fromfuture) — convert a Future into an Observable, but do not attempt to get the Future's value until a Subscriber subscribes (⁇) +* [**`fromRunnable( )`**](https://github.com/ReactiveX/RxJava/wiki/Async-Operators#fromrunnable) — convert a Runnable into an Observable that invokes the runable and emits its result when a Subscriber subscribes (`rxjava-async`) +* [**`generate( )`**](https://github.com/ReactiveX/RxJava/wiki/Phantom-Operators#generate-and-generateabsolutetime) — create an Observable that emits a sequence of items as generated by a function of your choosing (⁇) +* [**`generateAbsoluteTime( )`**](https://github.com/ReactiveX/RxJava/wiki/Phantom-Operators#generate-and-generateabsolutetime) — create an Observable that emits a sequence of items as generated by a function of your choosing, with each item emitted at an item-specific time (⁇) +* **`generator( )`** (clojure) — _see [**`generate( )`**](https://github.com/ReactiveX/RxJava/wiki/Phantom-Operators#generate-and-generateabsolutetime)_ +* [**`getIterator( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) — convert the sequence emitted by the Observable into an Iterator +* [**`groupBy( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#groupby) — divide an Observable into a set of Observables that emit groups of items from the original Observable, organized by key +* **`group-by( )`** (clojure) — _see [**`groupBy( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#groupby)_ +* [**`groupByUntil( )`**](https://github.com/ReactiveX/RxJava/wiki/Phantom-Operators) — a variant of the [`groupBy( )`](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#groupby) operator that closes any open GroupedObservable upon a signal from another Observable (⁇) +* [**`groupJoin( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#joins) — combine the items emitted by two Observables whenever one item from one Observable falls within a window of duration specified by an item emitted by the other Observable +* **`head( )`** (scala) — _see [**`first( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) (`BlockingObservable`)_ +* **`headOption( )`** (scala) — _see [**`firstOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables) or [**`firstOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) (`BlockingObservable`)_ +* **`headOrElse( )`** (scala) — _see [**`firstOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables) or [**`firstOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) (`BlockingObservable`)_ +* [**`ifThen( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#conditional-operators) — only emit the source Observable's sequence if a condition is true, otherwise emit an empty or default sequence (`contrib-computation-expressions`) +* [**`ignoreElements( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#ignoreelements) — discard the items emitted by the source Observable and only pass through the error or completed notification +* [**`interval( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables#interval) — create an Observable that emits a sequence of integers spaced by a given time interval +* **`into( )`** (clojure) — _see [**`reduce( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#reduce)_ +* [**`isEmpty( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#boolean-operators) — determine whether an Observable emits any items or not +* **`items( )`** (scala) — _see [**`just( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables#just)_ +* [**`join( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#joins) — combine the items emitted by two Observables whenever one item from one Observable falls within a window of duration specified by an item emitted by the other Observable +* [**`join( )`**](https://github.com/ReactiveX/RxJava/wiki/String-Observables) (`StringObservable`) — converts an Observable that emits a sequence of strings into an Observable that emits a single string that concatenates them all, separating them by a specified string +* [**`just( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables#just) — convert an object into an Observable that emits that object +* [**`last( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) (`BlockingObservable`) — block until the Observable completes, then return the last item emitted by the Observable +* [**`last( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#last) (`Observable`) — emit only the last item emitted by the source Observable +* **`lastOption( )`** (scala) — _see [**`lastOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables) or [**`lastOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) (`BlockingObservable`)_ +* [**`lastOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) (`BlockingObservable`) — block until the Observable completes, then return the last item emitted by the Observable or a default item if there is no last item +* [**`lastOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables) (`Observable`) — emit only the last item emitted by an Observable, or a default value if the source Observable is empty +* **`lastOrElse( )`** (scala) — _see [**`lastOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables) or [**`lastOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) (`BlockingObservable`)_ +* [**`latest( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) — returns an iterable that blocks until or unless the Observable emits an item that has not been returned by the iterable, then returns the latest such item +* **`length( )`** (scala) — _see [**`count( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#count)_ +* **`limit( )`** — _see [**`take( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#take)_ +* **`longCount( )`** (scala) — _see [**`countLong( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators)_ +* [**`map( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#map) — transform the items emitted by an Observable by applying a function to each of them +* **`mapcat( )`** (clojure) — _see [**`concatMap( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#concatmap)_ +* **`mapMany( )`** — _see: [**`flatMap( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#flatmap)_ +* [**`materialize( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) — convert an Observable into a list of Notifications +* [**`max( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#max) — emits the maximum value emitted by a source Observable (`rxjava-math`) +* [**`maxBy( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators) — emits the item emitted by the source Observable that has the maximum key value (`rxjava-math`) +* [**`merge( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#merge) — combine multiple Observables into one +* [**`mergeDelayError( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#mergedelayerror) — combine multiple Observables into one, allowing error-free Observables to continue before propagating errors +* **`merge-delay-error( )`** (clojure) — _see [**`mergeDelayError( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#mergedelayerror)_ +* **`mergeMap( )`** * — _see: [**`flatMap( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#flatmap)_ +* **`mergeMapIterable( )`** — _see: [**`flatMapIterable( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#flatmapiterable)_ +* **`mergeWith( )`** — _instance version of [**`merge( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#merge)_ +* [**`min( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#min) — emits the minimum value emitted by a source Observable (`rxjava-math`) +* [**`minBy( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators) — emits the item emitted by the source Observable that has the minimum key value (`rxjava-math`) +* [**`mostRecent( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) — returns an iterable that always returns the item most recently emitted by the Observable +* [**`multicast( )`**](https://github.com/ReactiveX/RxJava/wiki/Phantom-Operators#multicast) — represents an Observable as a Connectable Observable +* [**`never( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables#never) — create an Observable that emits nothing at all +* [**`next( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) — returns an iterable that blocks until the Observable emits another item, then returns that item +* **`nonEmpty( )`** (scala) — _see [**`isEmpty( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#boolean-operators)_ +* **`nth( )`** (clojure) — _see [**`elementAt( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#elementat) and [**`elementAtOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables)_ +* [**`observeOn( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) — specify on which Scheduler a Subscriber should observe the Observable +* [**`ofType( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#oftype) — emit only those items from the source Observable that are of a particular class +* [**`onBackpressureBlock( )`**](https://github.com/ReactiveX/RxJava/wiki/Backpressure#reactive-pull-backpressure-isnt-magic) — block the Observable's thread until the Observer is ready to accept more items from the Observable (⁇) +* [**`onBackpressureBuffer( )`**](https://github.com/ReactiveX/RxJava/wiki/Backpressure#reactive-pull-backpressure-isnt-magic) — maintain a buffer of all emissions from the source Observable and emit them to downstream Subscribers according to the requests they generate +* [**`onBackpressureDrop( )`**](https://github.com/ReactiveX/RxJava/wiki/Backpressure#reactive-pull-backpressure-isnt-magic) — drop emissions from the source Observable unless there is a pending request from a downstream Subscriber, in which case emit enough items to fulfill the request +* [**`onErrorFlatMap( )`**](https://github.com/ReactiveX/RxJava/wiki/Phantom-Operators#onerrorflatmap) — instructs an Observable to emit a sequence of items whenever it encounters an error (⁇) +* [**`onErrorResumeNext( )`**](https://github.com/ReactiveX/RxJava/wiki/Error-Handling-Operators#onerrorresumenext) — instructs an Observable to emit a sequence of items if it encounters an error +* [**`onErrorReturn( )`**](https://github.com/ReactiveX/RxJava/wiki/Error-Handling-Operators#onerrorreturn) — instructs an Observable to emit a particular item when it encounters an error +* [**`onExceptionResumeNext( )`**](https://github.com/ReactiveX/RxJava/wiki/Error-Handling-Operators#onexceptionresumenext) — instructs an Observable to continue emitting items after it encounters an exception (but not another variety of throwable) +* **`orElse( )`** (scala) — _see [**`defaultIfEmpty( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#conditional-operators)_ +* [**`parallel( )`**](https://github.com/ReactiveX/RxJava/wiki/Phantom-Operators#parallel) — split the work done on the emissions from an Observable into multiple Observables each operating on its own parallel thread (⁇) +* [**`parallelMerge( )`**](https://github.com/ReactiveX/RxJava/wiki/Phantom-Operators#parallelmerge) — combine multiple Observables into smaller number of Observables (⁇) +* [**`pivot( )`**](https://github.com/ReactiveX/RxJava/wiki/Phantom-Operators#pivot) — combine multiple sets of grouped observables so that they are arranged primarily by group rather than by set (⁇) +* [**`publish( )`**](https://github.com/ReactiveX/RxJava/wiki/Connectable-Observable-Operators) — represents an Observable as a Connectable Observable +* [**`publishLast( )`**](https://github.com/ReactiveX/RxJava/wiki/Phantom-Operators#publishlast) — represent an Observable as a Connectable Observable that emits only the last item emitted by the source Observable (⁇) +* [**`range( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables#range) — create an Observable that emits a range of sequential integers +* [**`reduce( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#reduce) — apply a function to each emitted item, sequentially, and emit only the final accumulated value +* **`reductions( )`** (clojure) — _see [**`scan( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#scan)_ +* [**`refCount( )`**](https://github.com/ReactiveX/RxJava/wiki/Connectable-Observable-Operators) — makes a Connectable Observable behave like an ordinary Observable +* [**`repeat( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables) — create an Observable that emits a particular item or sequence of items repeatedly +* [**`repeatWhen( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables#repeatwhen) — create an Observable that emits a particular item or sequence of items repeatedly, depending on the emissions of a second Observable +* [**`replay( )`**](https://github.com/ReactiveX/RxJava/wiki/Connectable-Observable-Operators#observablereplay) — ensures that all Subscribers see the same sequence of emitted items, even if they subscribe after the Observable begins emitting the items +* **`rest( )`** (clojure) — _see [**`next( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators#next)_ +* **`return( )`** (clojure) — _see [**`just( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables#just)_ +* [**`retry( )`**](https://github.com/ReactiveX/RxJava/wiki/Error-Handling-Operators#retry) — if a source Observable emits an error, resubscribe to it in the hopes that it will complete without error +* [**`retrywhen( )`**](https://github.com/ReactiveX/RxJava/wiki/Error-Handling-Operators#retrywhen) — if a source Observable emits an error, pass that error to another Observable to determine whether to resubscribe to the source +* [**`runAsync( )`**](https://github.com/ReactiveX/RxJava/wiki/Async-Operators) — returns a `StoppableObservable` that emits multiple actions as generated by a specified Action on a Scheduler (`rxjava-async`) +* [**`sample( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#sample) — emit the most recent items emitted by an Observable within periodic time intervals +* [**`scan( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#scan) — apply a function to each item emitted by an Observable, sequentially, and emit each successive value +* **`seq( )`** (clojure) — _see [**`getIterator( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators)_ +* [**`sequenceEqual( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators) — test the equality of sequences emitted by two Observables +* **`sequenceEqualWith( )`** (scala) — _instance version of [**`sequenceEqual( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators)_ +* [**`serialize( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators#serialize) — force an Observable to make serialized calls and to be well-behaved +* **`share( )`** — _see [**`refCount( )`**](https://github.com/ReactiveX/RxJava/wiki/Connectable-Observable-Operators)_ +* [**`single( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) (`BlockingObservable`) — if the source Observable completes after emitting a single item, return that item, otherwise throw an exception +* [**`single( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) (`Observable`) — if the source Observable completes after emitting a single item, emit that item, otherwise notify of an exception +* **`singleOption( )`** (scala) — _see [**`singleOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators#single-and-singleordefault) (`BlockingObservable`)_ +* [**`singleOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) (`BlockingObservable`) — if the source Observable completes after emitting a single item, return that item, otherwise return a default item +* [**`singleOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) (`Observable`) — if the source Observable completes after emitting a single item, emit that item, otherwise emit a default item +* **`singleOrElse( )`** (scala) — _see [**`singleOrDefault( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators)_ +* **`size( )`** (scala) — _see [**`count( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#count)_ +* [**`skip( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#skip) — ignore the first _n_ items emitted by an Observable +* [**`skipLast( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#skiplast) — ignore the last _n_ items emitted by an Observable +* [**`skipUntil( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#conditional-operators) — discard items emitted by a source Observable until a second Observable emits an item, then emit the remainder of the source Observable's items +* [**`skipWhile( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#conditional-operators) — discard items emitted by an Observable until a specified condition is false, then emit the remainder +* **`sliding( )`** (scala) — _see [**`window( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#window)_ +* **`slidingBuffer( )`** (scala) — _see [**`buffer( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#buffer)_ +* [**`split( )`**](https://github.com/ReactiveX/RxJava/wiki/String-Observables) (`StringObservable`) — converts an Observable of Strings into an Observable of Strings that treats the source sequence as a stream and splits it on a specified regex boundary +* [**`start( )`**](https://github.com/ReactiveX/RxJava/wiki/Async-Operators) — create an Observable that emits the return value of a function (`rxjava-async`) +* [**`startCancellableFuture( )`**](https://github.com/ReactiveX/RxJava/wiki/Phantom-Operators#fromcancellablefuture-startcancellablefuture-and-defercancellablefuture) — convert a function that returns Future into an Observable that emits that Future's return value in a way that monitors the subscription status of the Observable to determine whether to halt work on the Future (⁇)(`rxjava-async`) +* [**`startFuture( )`**](https://github.com/ReactiveX/RxJava/wiki/Async-Operators) — convert a function that returns Future into an Observable that emits that Future's return value (`rxjava-async`) +* [**`startWith( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#startwith) — emit a specified sequence of items before beginning to emit the items from the Observable +* [**`stringConcat( )`**](https://github.com/ReactiveX/RxJava/wiki/String-Observables) (`StringObservable`) — converts an Observable that emits a sequence of strings into an Observable that emits a single string that concatenates them all +* [**`subscribeOn( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) — specify which Scheduler an Observable should use when its subscription is invoked +* [**`sumDouble( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#sumdouble) — adds the Doubles emitted by an Observable and emits this sum (`rxjava-math`) +* [**`sumFloat( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#sumfloat) — adds the Floats emitted by an Observable and emits this sum (`rxjava-math`) +* [**`sumInt( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#sumint) — adds the Integers emitted by an Observable and emits this sum (`rxjava-math`) +* [**`sumLong( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#sumlong) — adds the Longs emitted by an Observable and emits this sum (`rxjava-math`) +* **`switch( )`** (scala) — _see [**`switchOnNext( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#switchonnext)_ +* [**`switchCase( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#conditional-operators) — emit the sequence from a particular Observable based on the results of an evaluation (`contrib-computation-expressions`) +* [**`switchMap( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#switchmap) — transform the items emitted by an Observable into Observables, and mirror those items emitted by the most-recently transformed Observable +* [**`switchOnNext( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#switchonnext) — convert an Observable that emits Observables into a single Observable that emits the items emitted by the most-recently emitted of those Observables +* **`synchronize( )`** — _see [**`serialize( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators)_ +* [**`take( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#take) — emit only the first _n_ items emitted by an Observable +* [**`takeFirst( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables) — emit only the first item emitted by an Observable, or the first item that meets some condition +* [**`takeLast( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#takelast) — only emit the last _n_ items emitted by an Observable +* [**`takeLastBuffer( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables) — emit the last _n_ items emitted by an Observable, as a single list item +* **`takeRight( )`** (scala) — _see [**`last( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#last) (`Observable`) or [**`takeLast( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#takelast)_ +* [**`takeUntil( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#conditional-operators) — emits the items from the source Observable until a second Observable emits an item +* [**`takeWhile( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#conditional-operators) — emit items emitted by an Observable as long as a specified condition is true, then skip the remainder +* **`take-while( )`** (clojure) — _see [**`takeWhile( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#conditional-operators)_ +* [**`then( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#rxjava-joins) — transform a series of `Pattern` objects via a `Plan` template (`rxjava-joins`) +* [**`throttleFirst( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#throttlefirst) — emit the first items emitted by an Observable within periodic time intervals +* [**`throttleLast( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#throttlelast) — emit the most recent items emitted by an Observable within periodic time intervals +* [**`throttleWithTimeout( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#throttlewithtimeout) — only emit an item from the source Observable after a particular timespan has passed without the Observable emitting any other items +* **`throw( )`** (clojure) — _see [**`error( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables#error)_ +* [**`timeInterval( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) — emit the time lapsed between consecutive emissions of a source Observable +* [**`timeout( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#timeout) — emit items from a source Observable, but issue an exception if no item is emitted in a specified timespan +* [**`timer( )`**](https://github.com/ReactiveX/RxJava/wiki/Creating-Observables#timer) — create an Observable that emits a single item after a given delay +* [**`timestamp( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) — attach a timestamp to every item emitted by an Observable +* [**`toAsync( )`**](https://github.com/ReactiveX/RxJava/wiki/Async-Operators) — convert a function or Action into an Observable that executes the function and emits its return value (`rxjava-async`) +* [**`toBlocking( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) — transform an Observable into a BlockingObservable +* **`toBlockingObservable( )`** - _see [**`toBlocking( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators)_ +* [**`toFuture( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) — convert the Observable into a Future +* [**`toIterable( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators) — convert the sequence emitted by the Observable into an Iterable +* **`toIterator( )`** — _see [**`getIterator( )`**](https://github.com/ReactiveX/RxJava/wiki/Blocking-Observable-Operators)_ +* [**`toList( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#tolist) — collect all items from an Observable and emit them as a single List +* [**`toMap( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#tomap) — convert the sequence of items emitted by an Observable into a map keyed by a specified key function +* [**`toMultimap( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#tomultimap) — convert the sequence of items emitted by an Observable into an ArrayList that is also a map keyed by a specified key function +* **`toSeq( )`** (scala) — _see [**`toList( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#tolist)_ +* [**`toSortedList( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#tosortedlist) — collect all items from an Observable and emit them as a single, sorted List +* **`tumbling( )`** (scala) — _see [**`window( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#window)_ +* **`tumblingBuffer( )`** (scala) — _see [**`buffer( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#buffer)_ +* [**`using( )`**](https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators) — create a disposable resource that has the same lifespan as an Observable +* [**`when( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#rxjava-joins) — convert a series of `Plan` objects into an Observable (`rxjava-joins`) +* **`where( )`** — _see: [**`filter( )`**](https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables#filter)_ +* [**`whileDo( )`**](https://github.com/ReactiveX/RxJava/wiki/Conditional-and-Boolean-Operators#conditional-operators) — if a condition is true, emit the source Observable's sequence and then repeat the sequence as long as the condition remains true (`contrib-computation-expressions`) +* [**`window( )`**](https://github.com/ReactiveX/RxJava/wiki/Transforming-Observables#window) — periodically subdivide items from an Observable into Observable windows and emit these windows rather than emitting the items one at a time +* [**`zip( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#zip) — combine sets of items emitted by two or more Observables together via a specified function and emit items based on the results of this function +* **`zipWith( )`** — _instance version of [**`zip( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#zip)_ +* **`zipWithIndex( )`** (scala) — _see [**`zip( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#zip)_ +* **`++`** (scala) — _see [**`concat( )`**](https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators)_ +* **`+:`** (scala) — _see [**`startWith( )`**](https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#startwith)_ -(⁇) — this proposed operator is not part of RxJava 1.0 \ No newline at end of file +(⁇) — this proposed operator is not part of RxJava 1.0 diff --git a/docs/Backpressure.md b/docs/Backpressure.md index d9e7bfa65a..8feec0d487 100644 --- a/docs/Backpressure.md +++ b/docs/Backpressure.md @@ -20,7 +20,7 @@ Cold Observables are ideal for the reactive pull model of backpressure described Your first line of defense against the problems of over-producing Observables is to use some of the ordinary set of Observable operators to reduce the number of emitted items to a more manageable number. The examples in this section will show how you might use such operators to handle a bursty Observable like the one illustrated in the following marble diagram: -​ +​ By fine-tuning the parameters to these operators you can ensure that a slow-consuming observer is not overwhelmed by a fast-producing Observable. @@ -33,7 +33,7 @@ The following diagrams show how you could use each of these operators on the bur ### sample (or throttleLast) The `sample` operator periodically "dips" into the sequence and emits only the most recently emitted item during each dip: -​ +​ ````groovy Observable burstySampled = bursty.sample(500, TimeUnit.MILLISECONDS); ```` @@ -41,7 +41,7 @@ Observable burstySampled = bursty.sample(500, TimeUnit.MILLISECONDS); ### throttleFirst The `throttleFirst` operator is similar, but emits not the most recently emitted item, but the first item that was emitted after the previous "dip": -​ +​ ````groovy Observable burstyThrottled = bursty.throttleFirst(500, TimeUnit.MILLISECONDS); ```` @@ -49,7 +49,7 @@ Observable burstyThrottled = bursty.throttleFirst(500, TimeUnit.MILLISE ### debounce (or throttleWithTimeout) The `debounce` operator emits only those items from the source Observable that are not followed by another item within a specified duration: -​ +​ ````groovy Observable burstyDebounced = bursty.debounce(10, TimeUnit.MILLISECONDS); ```` @@ -64,14 +64,14 @@ The following diagrams show how you could use each of these operators on the bur You could, for example, close and emit a buffer of items from the bursty Observable periodically, at a regular interval of time: -​ +​ ````groovy Observable> burstyBuffered = bursty.buffer(500, TimeUnit.MILLISECONDS); ```` Or you could get fancy, and collect items in buffers during the bursty periods and emit them at the end of each burst, by using the `debounce` operator to emit a buffer closing indicator to the `buffer` operator: -​ +​ ````groovy // we have to multicast the original bursty Observable so we can use it // both as our source and as the source for our buffer closing selector: @@ -86,14 +86,14 @@ Observable> burstyBuffered = burstyMulticast.buffer(burstyDebounce `window` is similar to `buffer`. One variant of `window` allows you to periodically emit Observable windows of items at a regular interval of time: -​ +​ ````groovy Observable> burstyWindowed = bursty.window(500, TimeUnit.MILLISECONDS); ```` You could also choose to emit a new window each time you have collected a particular number of items from the source Observable: -​ +​ ````groovy Observable> burstyWindowed = bursty.window(5); ```` @@ -158,11 +158,11 @@ For this to work, though, Observables _A_ and _B_ must respond correctly to the
onBackpressureBuffer
-
maintains a buffer of all emissions from the source Observable and emits them to downstream Subscribers according to the requests they generate

an experimental version of this operator (not available in RxJava 1.0) allows you to set the capacity of the buffer; applying this operator will cause the resulting Observable to terminate with an error if this buffer is overrun​
+
maintains a buffer of all emissions from the source Observable and emits them to downstream Subscribers according to the requests they generate

an experimental version of this operator (not available in RxJava 1.0) allows you to set the capacity of the buffer; applying this operator will cause the resulting Observable to terminate with an error if this buffer is overrun​
onBackpressureDrop
-
drops emissions from the source Observable unless there is a pending request from a downstream Subscriber, in which case it will emit enough items to fulfill the request
​
+
drops emissions from the source Observable unless there is a pending request from a downstream Subscriber, in which case it will emit enough items to fulfill the request
​
onBackpressureBlock (experimental, not in RxJava 1.0)
-
blocks the thread on which the source Observable is operating until such time as a Subscriber issues a request for items, and then unblocks the thread only so long as there are pending requests
+
blocks the thread on which the source Observable is operating until such time as a Subscriber issues a request for items, and then unblocks the thread only so long as there are pending requests
If you do not apply any of these operators to an Observable that does not support backpressure, _and_ if either you as the Subscriber or some operator between you and the Observable attempts to apply reactive pull backpressure, you will encounter a `MissingBackpressureException` which you will be notified of via your `onError()` callback. @@ -172,4 +172,4 @@ If you do not apply any of these operators to an Observable that does not suppor If the standard operators are providing the expected behavior, [one can write custom operators in RxJava](https://github.com/ReactiveX/RxJava/wiki/Implementing-custom-operators-(draft)). # See also -* [RxJava 0.20.0-RC1 release notes](https://github.com/ReactiveX/RxJava/releases/tag/0.20.0-RC1) \ No newline at end of file +* [RxJava 0.20.0-RC1 release notes](https://github.com/ReactiveX/RxJava/releases/tag/0.20.0-RC1) diff --git a/docs/Creating-Observables.md b/docs/Creating-Observables.md index 8e31a56528..360e03ab09 100644 --- a/docs/Creating-Observables.md +++ b/docs/Creating-Observables.md @@ -37,8 +37,8 @@ There exist overloads with 2 to 9 arguments for convenience, which objects (with ```java Observable observable = Observable.just("1", "A", "3.2", "def"); -observable.subscribe(item -> System.out.print(item), error -> error.printStackTrace, - () -> System.out.println()); + observable.subscribe(item -> System.out.print(item), error -> error.printStackTrace(), + () -> System.out.println()); ``` ## From @@ -80,7 +80,7 @@ for (int i = 0; i < array.length; i++) { array[i] = i; } -Observable observable = Observable.fromIterable(array); +Observable observable = Observable.fromArray(array); observable.subscribe(item -> System.out.println(item), error -> error.printStackTrace(), () -> System.out.println("Done")); @@ -155,7 +155,7 @@ Given a pre-existing, already running or already completed `java.util.concurrent #### fromFuture example: ```java -ScheduledExecutorService executor = Executors.newSingleThreadedScheduledExecutor(); +ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor(); Future future = executor.schedule(() -> "Hello world!", 1, TimeUnit.SECONDS); @@ -298,10 +298,10 @@ String greeting = "Hello World!"; Observable indexes = Observable.range(0, greeting.length()); -Observable characters = indexes +Observable characters = indexes .map(index -> greeting.charAt(index)); -characters.subscribe(character -> System.out.print(character), erro -> error.printStackTrace(), +characters.subscribe(character -> System.out.print(character), error -> error.printStackTrace(), () -> System.out.println()); ``` @@ -396,7 +396,7 @@ Observable error = Observable.error(new IOException()); error.subscribe( v -> System.out.println("This should never be printed!"), - error -> error.printStackTrace(), + e -> e.printStackTrace(), () -> System.out.println("This neither!")); ``` @@ -423,4 +423,4 @@ for (int i = 0; i < 10; i++) { error -> error.printStackTrace(), () -> System.out.println("Done")); } -``` +``` \ No newline at end of file diff --git a/docs/Filtering-Observables.md b/docs/Filtering-Observables.md index 7e12d91094..620800dc8c 100644 --- a/docs/Filtering-Observables.md +++ b/docs/Filtering-Observables.md @@ -1,22 +1,760 @@ -This page shows operators you can use to filter and select items emitted by Observables. - -* [**`filter( )`**](http://reactivex.io/documentation/operators/filter.html) — filter items emitted by an Observable -* [**`takeLast( )`**](http://reactivex.io/documentation/operators/takelast.html) — only emit the last _n_ items emitted by an Observable -* [**`last( )`**](http://reactivex.io/documentation/operators/last.html) — emit only the last item emitted by an Observable -* [**`lastOrDefault( )`**](http://reactivex.io/documentation/operators/last.html) — emit only the last item emitted by an Observable, or a default value if the source Observable is empty -* [**`takeLastBuffer( )`**](http://reactivex.io/documentation/operators/takelast.html) — emit the last _n_ items emitted by an Observable, as a single list item -* [**`skip( )`**](http://reactivex.io/documentation/operators/skip.html) — ignore the first _n_ items emitted by an Observable -* [**`skipLast( )`**](http://reactivex.io/documentation/operators/skiplast.html) — ignore the last _n_ items emitted by an Observable -* [**`take( )`**](http://reactivex.io/documentation/operators/take.html) — emit only the first _n_ items emitted by an Observable -* [**`first( )` and `takeFirst( )`**](http://reactivex.io/documentation/operators/first.html) — emit only the first item emitted by an Observable, or the first item that meets some condition -* [**`firstOrDefault( )`**](http://reactivex.io/documentation/operators/first.html) — emit only the first item emitted by an Observable, or the first item that meets some condition, or a default value if the source Observable is empty -* [**`elementAt( )`**](http://reactivex.io/documentation/operators/elementat.html) — emit item _n_ emitted by the source Observable -* [**`elementAtOrDefault( )`**](http://reactivex.io/documentation/operators/elementat.html) — emit item _n_ emitted by the source Observable, or a default item if the source Observable emits fewer than _n_ items -* [**`sample( )` or `throttleLast( )`**](http://reactivex.io/documentation/operators/sample.html) — emit the most recent items emitted by an Observable within periodic time intervals -* [**`throttleFirst( )`**](http://reactivex.io/documentation/operators/sample.html) — emit the first items emitted by an Observable within periodic time intervals -* [**`throttleWithTimeout( )` or `debounce( )`**](http://reactivex.io/documentation/operators/debounce.html) — only emit an item from the source Observable after a particular timespan has passed without the Observable emitting any other items -* [**`timeout( )`**](http://reactivex.io/documentation/operators/timeout.html) — emit items from a source Observable, but issue an exception if no item is emitted in a specified timespan -* [**`distinct( )`**](http://reactivex.io/documentation/operators/distinct.html) — suppress duplicate items emitted by the source Observable -* [**`distinctUntilChanged( )`**](http://reactivex.io/documentation/operators/distinct.html) — suppress duplicate consecutive items emitted by the source Observable -* [**`ofType( )`**](http://reactivex.io/documentation/operators/filter.html) — emit only those items from the source Observable that are of a particular class -* [**`ignoreElements( )`**](http://reactivex.io/documentation/operators/ignoreelements.html) — discard the items emitted by the source Observable and only pass through the error or completed notification +This page shows operators you can use to filter and select items emitted by reactive sources, such as `Observable`s. + +# Outline + +- [`debounce`](#debounce) +- [`distinct`](#distinct) +- [`distinctUntilChanged`](#distinctuntilchanged) +- [`elementAt`](#elementat) +- [`elementAtOrError`](#elementatorerror) +- [`filter`](#filter) +- [`first`](#first) +- [`firstElement`](#firstelement) +- [`firstOrError`](#firstorerror) +- [`ignoreElement`](#ignoreelement) +- [`ignoreElements`](#ignoreelements) +- [`last`](#last) +- [`lastElement`](#lastelement) +- [`lastOrError`](#lastorerror) +- [`ofType`](#oftype) +- [`sample`](#sample) +- [`skip`](#skip) +- [`skipLast`](#skiplast) +- [`take`](#take) +- [`takeLast`](#takelast) +- [`throttleFirst`](#throttlefirst) +- [`throttleLast`](#throttlelast) +- [`throttleLatest`](#throttlelatest) +- [`throttleWithTimeout`](#throttlewithtimeout) +- [`timeout`](#timeout) + +## debounce + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/debounce.html](http://reactivex.io/documentation/operators/debounce.html) + +Drops items emitted by a reactive source that are followed by newer items before the given timeout value expires. The timer resets on each emission. + +This operator keeps track of the most recent emitted item, and emits this item only when enough time has passed without the source emitting any other items. + +### debounce example + +```java +// Diagram: +// -A--------------B----C-D-------------------E-|----> +// a---------1s +// b---------1s +// c---------1s +// d---------1s +// e-|----> +// -----------A---------------------D-----------E-|--> + +Observable source = Observable.create(emitter -> { + emitter.onNext("A"); + + Thread.sleep(1_500); + emitter.onNext("B"); + + Thread.sleep(500); + emitter.onNext("C"); + + Thread.sleep(250); + emitter.onNext("D"); + + Thread.sleep(2_000); + emitter.onNext("E"); + emitter.onComplete(); +}); + +source.subscribeOn(Schedulers.io()) + .debounce(1, TimeUnit.SECONDS) + .blockingSubscribe( + item -> System.out.println("onNext: " + item), + Throwable::printStackTrace, + () -> System.out.println("onComplete")); + +// prints: +// onNext: A +// onNext: D +// onNext: E +// onComplete +``` + +## distinct + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/distinct.html](http://reactivex.io/documentation/operators/distinct.html) + +Filters a reactive source by only emitting items that are distinct by comparison from previous items. A `io.reactivex.functions.Function` can be specified that projects each item emitted by the source into a new value that will be used for comparison with previous projected values. + +### distinct example + +```java +Observable.just(2, 3, 4, 4, 2, 1) + .distinct() + .subscribe(System.out::println); + +// prints: +// 2 +// 3 +// 4 +// 1 +``` + +## distinctUntilChanged + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/distinct.html](http://reactivex.io/documentation/operators/distinct.html) + +Filters a reactive source by only emitting items that are distinct by comparison from their immediate predecessors. A `io.reactivex.functions.Function` can be specified that projects each item emitted by the source into a new value that will be used for comparison with previous projected values. Alternatively, a `io.reactivex.functions.BiPredicate` can be specified that is used as the comparator function to compare immediate predecessors with each other. + +### distinctUntilChanged example + +```java +Observable.just(1, 1, 2, 1, 2, 3, 3, 4) + .distinctUntilChanged() + .subscribe(System.out::println); + +// prints: +// 1 +// 2 +// 1 +// 2 +// 3 +// 4 +``` + +## elementAt + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/elementat.html](http://reactivex.io/documentation/operators/elementat.html) + +Emits the single item at the specified zero-based index in a sequence of emissions from a reactive source. A default item can be specified that will be emitted if the specified index is not within the sequence. + +### elementAt example + +```java +Observable source = Observable.generate(() -> 1L, (state, emitter) -> { + emitter.onNext(state); + + return state + 1L; +}).scan((product, x) -> product * x); + +Maybe element = source.elementAt(5); +element.subscribe(System.out::println); + +// prints 720 +``` + +## elementAtOrError + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/elementat.html](http://reactivex.io/documentation/operators/elementat.html) + +Emits the single item at the specified zero-based index in a sequence of emissions from a reactive source, or signals a `java.util.NoSuchElementException` if the specified index is not within the sequence. + +### elementAtOrError example + +```java +Observable source = Observable.just("Kirk", "Spock", "Chekov", "Sulu"); +Single element = source.elementAtOrError(4); + +element.subscribe( + name -> System.out.println("onSuccess will not be printed!"), + error -> System.out.println("onError: " + error)); + +// prints: +// onError: java.util.NoSuchElementException +``` + +## filter + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/filter.html](http://reactivex.io/documentation/operators/filter.html) + +Filters items emitted by a reactive source by only emitting those that satisfy a specified predicate. + +### filter example + +```java +Observable.just(1, 2, 3, 4, 5, 6) + .filter(x -> x % 2 == 0) + .subscribe(System.out::println); + +// prints: +// 2 +// 4 +// 6 +``` + +## first + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/first.html](http://reactivex.io/documentation/operators/first.html) + +Emits only the first item emitted by a reactive source, or emits the given default item if the source completes without emitting an item. This differs from [`firstElement`](#firstelement) in that this operator returns a `Single` whereas [`firstElement`](#firstelement) returns a `Maybe`. + +### first example + +```java +Observable source = Observable.just("A", "B", "C"); +Single firstOrDefault = source.first("D"); + +firstOrDefault.subscribe(System.out::println); + +// prints A +``` + +## firstElement + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/first.html](http://reactivex.io/documentation/operators/first.html) + +Emits only the first item emitted by a reactive source, or just completes if the source completes without emitting an item. This differs from [`first`](#first) in that this operator returns a `Maybe` whereas [`first`](#first) returns a `Single`. + +### firstElement example + +```java +Observable source = Observable.just("A", "B", "C"); +Maybe first = source.firstElement(); + +first.subscribe(System.out::println); + +// prints A +``` + +## firstOrError + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/first.html](http://reactivex.io/documentation/operators/first.html) + +Emits only the first item emitted by a reactive source, or signals a `java.util.NoSuchElementException` if the source completes without emitting an item. + +### firstOrError example + +```java +Observable emptySource = Observable.empty(); +Single firstOrError = emptySource.firstOrError(); + +firstOrError.subscribe( + element -> System.out.println("onSuccess will not be printed!"), + error -> System.out.println("onError: " + error)); + +// prints: +// onError: java.util.NoSuchElementException +``` + +## ignoreElement + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/ignoreelements.html](http://reactivex.io/documentation/operators/ignoreelements.html) + +Ignores the single item emitted by a `Single` or `Maybe` source, and returns a `Completable` that signals only the error or completion event from the the source. + +### ignoreElement example + +```java +Single source = Single.timer(1, TimeUnit.SECONDS); +Completable completable = source.ignoreElement(); + +completable.doOnComplete(() -> System.out.println("Done!")) + .blockingAwait(); + +// prints (after 1 second): +// Done! +``` + +## ignoreElements + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/ignoreelements.html](http://reactivex.io/documentation/operators/ignoreelements.html) + +Ignores all items from the `Observable` or `Flowable` source, and returns a `Completable` that signals only the error or completion event from the source. + +### ignoreElements example + +```java +Observable source = Observable.intervalRange(1, 5, 1, 1, TimeUnit.SECONDS); +Completable completable = source.ignoreElements(); + +completable.doOnComplete(() -> System.out.println("Done!")) + .blockingAwait(); + +// prints (after 5 seconds): +// Done! +``` + +## last + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/last.html](http://reactivex.io/documentation/operators/last.html) + +Emits only the last item emitted by a reactive source, or emits the given default item if the source completes without emitting an item. This differs from [`lastElement`](#lastelement) in that this operator returns a `Single` whereas [`lastElement`](#lastelement) returns a `Maybe`. + +### last example + +```java +Observable source = Observable.just("A", "B", "C"); +Single lastOrDefault = source.last("D"); + +lastOrDefault.subscribe(System.out::println); + +// prints C +``` + +## lastElement + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/last.html](http://reactivex.io/documentation/operators/last.html) + +Emits only the last item emitted by a reactive source, or just completes if the source completes without emitting an item. This differs from [`last`](#last) in that this operator returns a `Maybe` whereas [`last`](#last) returns a `Single`. + +### lastElement example + +```java +Observable source = Observable.just("A", "B", "C"); +Maybe last = source.lastElement(); + +last.subscribe(System.out::println); + +// prints C +``` + +## lastOrError + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/last.html](http://reactivex.io/documentation/operators/last.html) + +Emits only the last item emitted by a reactive source, or signals a `java.util.NoSuchElementException` if the source completes without emitting an item. + +### lastOrError example + +```java +Observable emptySource = Observable.empty(); +Single lastOrError = emptySource.lastOrError(); + +lastOrError.subscribe( + element -> System.out.println("onSuccess will not be printed!"), + error -> System.out.println("onError: " + error)); + +// prints: +// onError: java.util.NoSuchElementException +``` + +## ofType + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/filter.html](http://reactivex.io/documentation/operators/filter.html) + +Filters items emitted by a reactive source by only emitting those of the specified type. + +### ofType example + +```java +Observable numbers = Observable.just(1, 4.0, 3, 2.71, 2f, 7); +Observable integers = numbers.ofType(Integer.class); + +integers.subscribe((Integer x) -> System.out.println(x)); + +// prints: +// 1 +// 3 +// 7 +``` + +## sample + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/sample.html](http://reactivex.io/documentation/operators/sample.html) + +Filters items emitted by a reactive source by only emitting the most recently emitted item within periodic time intervals. + +### sample example + +```java +// Diagram: +// -A----B-C-------D-----E-|--> +// -0s-----c--1s---d----2s-|--> +// -----------C---------D--|--> + +Observable source = Observable.create(emitter -> { + emitter.onNext("A"); + + Thread.sleep(500); + emitter.onNext("B"); + + Thread.sleep(200); + emitter.onNext("C"); + + Thread.sleep(800); + emitter.onNext("D"); + + Thread.sleep(600); + emitter.onNext("E"); + emitter.onComplete(); +}); + +source.subscribeOn(Schedulers.io()) + .sample(1, TimeUnit.SECONDS) + .blockingSubscribe( + item -> System.out.println("onNext: " + item), + Throwable::printStackTrace, + () -> System.out.println("onComplete")); + +// prints: +// onNext: C +// onNext: D +// onComplete +``` + +## skip + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/skip.html](http://reactivex.io/documentation/operators/skip.html) + +Drops the first *n* items emitted by a reactive source, and emits the remaining items. + +### skip example + +```java +Observable source = Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); + +source.skip(4) + .subscribe(System.out::println); + +// prints: +// 5 +// 6 +// 7 +// 8 +// 9 +// 10 +``` + +## skipLast + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/skiplast.html](http://reactivex.io/documentation/operators/skiplast.html) + +Drops the last *n* items emitted by a reactive source, and emits the remaining items. + +### skipLast example + +```java +Observable source = Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); + +source.skipLast(4) + .subscribe(System.out::println); + +// prints: +// 1 +// 2 +// 3 +// 4 +// 5 +// 6 +``` + +## take + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/take.html](http://reactivex.io/documentation/operators/take.html) + +Emits only the first *n* items emitted by a reactive source. + +### take example + +```java +Observable source = Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); + +source.take(4) + .subscribe(System.out::println); + +// prints: +// 1 +// 2 +// 3 +// 4 +``` + +## takeLast + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/takelast.html](http://reactivex.io/documentation/operators/takelast.html) + +Emits only the last *n* items emitted by a reactive source. + +### takeLast example + +```java +Observable source = Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); + +source.takeLast(4) + .subscribe(System.out::println); + +// prints: +// 7 +// 8 +// 9 +// 10 +``` + +## throttleFirst + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/sample.html](http://reactivex.io/documentation/operators/sample.html) + +Emits only the first item emitted by a reactive source during sequential time windows of a specified duration. + +### throttleFirst example + +```java +// Diagram: +// -A----B-C-------D-----E-|--> +// a---------1s +// d-------|--> +// -A--------------D-------|--> + +Observable source = Observable.create(emitter -> { + emitter.onNext("A"); + + Thread.sleep(500); + emitter.onNext("B"); + + Thread.sleep(200); + emitter.onNext("C"); + + Thread.sleep(800); + emitter.onNext("D"); + + Thread.sleep(600); + emitter.onNext("E"); + emitter.onComplete(); +}); + +source.subscribeOn(Schedulers.io()) + .throttleFirst(1, TimeUnit.SECONDS) + .blockingSubscribe( + item -> System.out.println("onNext: " + item), + Throwable::printStackTrace, + () -> System.out.println("onComplete")); + +// prints: +// onNext: A +// onNext: D +// onComplete +``` + +## throttleLast + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/sample.html](http://reactivex.io/documentation/operators/sample.html) + +Emits only the last item emitted by a reactive source during sequential time windows of a specified duration. + +### throttleLast example + +```java +// Diagram: +// -A----B-C-------D-----E-|--> +// -0s-----c--1s---d----2s-|--> +// -----------C---------D--|--> + +Observable source = Observable.create(emitter -> { + emitter.onNext("A"); + + Thread.sleep(500); + emitter.onNext("B"); + + Thread.sleep(200); + emitter.onNext("C"); + + Thread.sleep(800); + emitter.onNext("D"); + + Thread.sleep(600); + emitter.onNext("E"); + emitter.onComplete(); +}); + +source.subscribeOn(Schedulers.io()) + .throttleLast(1, TimeUnit.SECONDS) + .blockingSubscribe( + item -> System.out.println("onNext: " + item), + Throwable::printStackTrace, + () -> System.out.println("onComplete")); + +// prints: +// onNext: C +// onNext: D +// onComplete +``` + +## throttleLatest + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/sample.html](http://reactivex.io/documentation/operators/sample.html) + +Emits the next item emitted by a reactive source, then periodically emits the latest item (if any) when the specified timeout elapses between them. + +### throttleLatest example + +```java +// Diagram: +// -A----B-C-------D-----E-|--> +// -a------c--1s +// -----d----1s +// -e-|--> +// -A---------C---------D--|--> + +Observable source = Observable.create(emitter -> { + emitter.onNext("A"); + + Thread.sleep(500); + emitter.onNext("B"); + + Thread.sleep(200); + emitter.onNext("C"); + + Thread.sleep(800); + emitter.onNext("D"); + + Thread.sleep(600); + emitter.onNext("E"); + emitter.onComplete(); +}); + +source.subscribeOn(Schedulers.io()) + .throttleLatest(1, TimeUnit.SECONDS) + .blockingSubscribe( + item -> System.out.println("onNext: " + item), + Throwable::printStackTrace, + () -> System.out.println("onComplete")); + +// prints: +// onNext: A +// onNext: C +// onNext: D +// onComplete +``` + +## throttleWithTimeout + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_off.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/debounce.html](http://reactivex.io/documentation/operators/debounce.html) + +> Alias to [debounce](#debounce) + +Drops items emitted by a reactive source that are followed by newer items before the given timeout value expires. The timer resets on each emission. + +### throttleWithTimeout example + +```java +// Diagram: +// -A--------------B----C-D-------------------E-|----> +// a---------1s +// b---------1s +// c---------1s +// d---------1s +// e-|----> +// -----------A---------------------D-----------E-|--> + +Observable source = Observable.create(emitter -> { + emitter.onNext("A"); + + Thread.sleep(1_500); + emitter.onNext("B"); + + Thread.sleep(500); + emitter.onNext("C"); + + Thread.sleep(250); + emitter.onNext("D"); + + Thread.sleep(2_000); + emitter.onNext("E"); + emitter.onComplete(); +}); + +source.subscribeOn(Schedulers.io()) + .throttleWithTimeout(1, TimeUnit.SECONDS) + .blockingSubscribe( + item -> System.out.println("onNext: " + item), + Throwable::printStackTrace, + () -> System.out.println("onComplete")); + +// prints: +// onNext: A +// onNext: D +// onNext: E +// onComplete +``` + +## timeout + +**Available in:** ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Flowable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Observable`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Maybe`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Single`, ![image](https://raw.github.com/wiki/ReactiveX/RxJava/images/checkmark_on.png) `Completable` + +**ReactiveX documentation:** [http://reactivex.io/documentation/operators/timeout.html](http://reactivex.io/documentation/operators/timeout.html) + +Emits the items from the `Observable` or `Flowable` source, but terminates with a `java.util.concurrent.TimeoutException` if the next item is not emitted within the specified timeout duration starting from the previous item. For `Maybe`, `Single` and `Completable` the specified timeout duration specifies the maximum time to wait for a success or completion event to arrive. If the `Maybe`, `Single` or `Completable` does not complete within the given time a `java.util.concurrent.TimeoutException` will be emitted. + +### timeout example + +```java +// Diagram: +// -A-------B---C-----------D-|--> +// a---------1s +// b---------1s +// c---------1s +// -A-------B---C---------X------> + +Observable source = Observable.create(emitter -> { + emitter.onNext("A"); + + Thread.sleep(800); + emitter.onNext("B"); + + Thread.sleep(400); + emitter.onNext("C"); + + Thread.sleep(1200); + emitter.onNext("D"); + emitter.onComplete(); +}); + +source.timeout(1, TimeUnit.SECONDS) + .subscribe( + item -> System.out.println("onNext: " + item), + error -> System.out.println("onError: " + error), + () -> System.out.println("onComplete will not be printed!")); + +// prints: +// onNext: A +// onNext: B +// onNext: C +// onError: java.util.concurrent.TimeoutException: The source did not signal an event for 1 seconds and has been terminated. +``` diff --git a/docs/How-To-Use-RxJava.md b/docs/How-To-Use-RxJava.md index d10274d959..16d156caa9 100644 --- a/docs/How-To-Use-RxJava.md +++ b/docs/How-To-Use-RxJava.md @@ -11,15 +11,20 @@ You can find additional code examples in the `/src/examples` folders of each [la ### Java ```java -public static void hello(String... names) { - Observable.from(names).subscribe(new Action1() { - - @Override - public void call(String s) { - System.out.println("Hello " + s + "!"); - } +public static void hello(String... args) { + Flowable.fromArray(args).subscribe(s -> System.out.println("Hello " + s + "!")); +} +``` - }); +If your platform doesn't support Java 8 lambdas (yet), you have to create an inner class of ```Consumer``` manually: +```java +public static void hello(String... args) { + Flowable.fromArray(args).subscribe(new Consumer() { + @Override + public void accept(String s) { + System.out.println("Hello " + s + "!"); + } + }); } ``` @@ -397,4 +402,4 @@ myModifiedObservable = myObservable.onErrorResumeNext({ t -> Throwable myThrowable = myCustomizedThrowableCreator(t); return (Observable.error(myThrowable)); }); -``` \ No newline at end of file +``` diff --git a/docs/Problem-Solving-Examples-in-RxJava.md b/docs/Problem-Solving-Examples-in-RxJava.md index 1b41c2a122..6b848ae693 100644 --- a/docs/Problem-Solving-Examples-in-RxJava.md +++ b/docs/Problem-Solving-Examples-in-RxJava.md @@ -1,4 +1,4 @@ -This page will present some elementary RxJava puzzles and walk through some solutions (using the Groovy language implementation of RxJava) as a way of introducing you to some of the RxJava operators. +This page will present some elementary RxJava puzzles and walk through some solutions as a way of introducing you to some of the RxJava operators. # Project Euler problem #1 @@ -7,10 +7,22 @@ There used to be a site called "Project Euler" that presented a series of mathem > If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23. Find the sum of all the multiples of 3 or 5 below 1000. There are several ways we could go about this with RxJava. We might, for instance, begin by going through all of the natural numbers below 1000 with [`range`](Creating-Observables#range) and then [`filter`](Filtering-Observables#filter) out those that are not a multiple either of 3 or of 5: +### Java +```java +Observable threesAndFives = Observable.range(1, 999).filter(e -> e % 3 == 0 || e % 5 == 0); +``` +### Groovy ````groovy def threesAndFives = Observable.range(1,999).filter({ !((it % 3) && (it % 5)) }); ```` Or, we could generate two Observable sequences, one containing the multiples of three and the other containing the multiples of five (by [`map`](https://github.com/Netflix/RxJava/wiki/Transforming-Observables#map)ping each value onto its appropriate multiple), making sure to only generating new multiples while they are less than 1000 (the [`takeWhile`](Conditional-and-Boolean-Operators#takewhile-and-takewhilewithindex) operator will help here), and then [`merge`](Combining-Observables#merge) these sets: +### Java +```java +Observable threes = Observable.range(1, 999).map(e -> e * 3).takeWhile(e -> e < 1000); +Observable fives = Observable.range(1, 999).map(e -> e * 5).takeWhile(e -> e < 1000); +Observable threesAndFives = Observable.merge(threes, fives).distinct(); +``` +### Groovy ````groovy def threes = Observable.range(1,999).map({it*3}).takeWhile({it<1000}); def fives = Observable.range(1,999).map({it*5}).takeWhile({it<1000}); @@ -21,6 +33,11 @@ Don't forget the [`distinct`](Filtering-Observables#distinct) operator here, oth Next, we want to sum up the numbers in the resulting sequence. If you have installed the optional `rxjava-math` module, this is elementary: just use an operator like [`sumInteger` or `sumLong`](Mathematical-and-Aggregate-Operators#suminteger-sumlong-sumfloat-and-sumdouble) on the `threesAndFives` Observable. But what if you don't have this module? How could you use standard RxJava operators to sum up a sequence and emit that sum? There are a number of operators that reduce a sequence emitted by a source Observable to a single value emitted by the resulting Observable. Most of the ones that are not in the `rxjava-math` module emit boolean evaluations of the sequence; we want something that can emit a number. The [`reduce`](Mathematical-and-Aggregate-Operators#reduce) operator will do the job: +### Java +```java +Single summer = threesAndFives.reduce(0, (a, b) -> a + b); +``` +### Groovy ````groovy def summer = threesAndFives.reduce(0, { a, b -> a+b }); ```` @@ -38,6 +55,12 @@ Here is how `reduce` gets the job done. It starts with 0 as a seed. Then, with e Finally, we want to see the result. This means we must [subscribe](Observable#onnext-oncompleted-and-onerror) to the Observable we have constructed: + +### Java +```java +summer.subscribe(System.out::print); +``` +### Groovy ````groovy summer.subscribe({println(it);}); ```` @@ -47,11 +70,24 @@ summer.subscribe({println(it);}); How could you create an Observable that emits [the Fibonacci sequence](http://en.wikipedia.org/wiki/Fibonacci_number)? The most direct way would be to use the [`create`](Creating-Observables#wiki-create) operator to make an Observable "from scratch," and then use a traditional loop within the closure you pass to that operator to generate the sequence. Something like this: +### Java +```java +Observable fibonacci = Observable.create(emitter -> { + int f1 = 0, f2 = 1, f = 1; + while (!emitter.isDisposed()) { + emitter.onNext(f); + f = f1 + f2; + f1 = f2; + f2 = f; + } +}); +``` +### Groovy ````groovy -def fibonacci = Observable.create({ observer -> - def f1=0; f2=1, f=1; - while(!observer.isUnsubscribed() { - observer.onNext(f); +def fibonacci = Observable.create({ emitter -> + def f1=0, f2=1, f=1; + while(!emitter.isDisposed()) { + emitter.onNext(f); f = f1+f2; f1 = f2; f2 = f; @@ -61,7 +97,16 @@ def fibonacci = Observable.create({ observer -> But this is a little too much like ordinary linear programming. Is there some way we can instead create this sequence by composing together existing Observable operators? Here's an option that does this: -```` +### Java +```java +Observable fibonacci = + Observable.fromArray(0) + .repeat() + .scan(new int[]{0, 1}, (a, b) -> new int[]{a[1], a[0] + a[1]}) + .map(a -> a[1]); +``` +### Groovy +````groovy def fibonacci = Observable.from(0).repeat().scan([0,1], { a,b -> [a[1], a[0]+a[1]] }).map({it[1]}); ```` It's a little [janky](http://www.urbandictionary.com/define.php?term=janky). Let's walk through it: @@ -73,6 +118,11 @@ This has the effect of emitting the following sequence of items: `[0,1], [1,1], The second item in this array describes the Fibonacci sequence. We can use `map` to reduce the sequence to just that item. To print out a portion of this sequence (using either method), you would use code like the following: +### Java +```java +fibonacci.take(15).subscribe(System.out::println); +``` +### Groovy ````groovy fibonnaci.take(15).subscribe({println(it)})]; ```` diff --git a/docs/What's-different-in-2.0.md b/docs/What's-different-in-2.0.md index fac50df56d..30f9a4ccba 100644 --- a/docs/What's-different-in-2.0.md +++ b/docs/What's-different-in-2.0.md @@ -1,6 +1,6 @@ -RxJava 2.0 has been completely rewritten from scratch on top of the Reactive-Streams specification. The specification itself has evolved out of RxJava 1.x and provides a common baseline for reactive systems and libraries. +RxJava 2.0 has been completely rewritten from scratch on top of the Reactive Streams specification. The specification itself has evolved out of RxJava 1.x and provides a common baseline for reactive systems and libraries. -Because Reactive-Streams has a different architecture, it mandates changes to some well known RxJava types. This wiki page attempts to summarize what has changed and describes how to rewrite 1.x code into 2.x code. +Because Reactive Streams has a different architecture, it mandates changes to some well known RxJava types. This wiki page attempts to summarize what has changed and describes how to rewrite 1.x code into 2.x code. For technical details on how to write operators for 2.x, please visit the [Writing Operators](https://github.com/ReactiveX/RxJava/wiki/Writing-operators-for-2.0) wiki page. @@ -20,7 +20,7 @@ For technical details on how to write operators for 2.x, please visit the [Writi - [Subscriber](#subscriber) - [Subscription](#subscription) - [Backpressure](#backpressure) - - [Reactive-Streams compliance](#reactive-streams-compliance) + - [Reactive Streams compliance](#reactive-streams-compliance) - [Runtime hooks](#runtime-hooks) - [Error handling](#error-handling) - [Scheduler](#schedulers) @@ -105,7 +105,7 @@ When architecting dataflows (as an end-consumer of RxJava) or deciding upon what # Single -The 2.x `Single` reactive base type, which can emit a single `onSuccess` or `onError` has been redesigned from scratch. Its architecture now derives from the Reactive-Streams design. Its consumer type (`rx.Single.SingleSubscriber`) has been changed from being a class that accepts `rx.Subscription` resources to be an interface `io.reactivex.SingleObserver` that has only 3 methods: +The 2.x `Single` reactive base type, which can emit a single `onSuccess` or `onError` has been redesigned from scratch. Its architecture now derives from the Reactive Streams design. Its consumer type (`rx.Single.SingleSubscriber`) has been changed from being a class that accepts `rx.Subscription` resources to be an interface `io.reactivex.SingleObserver` that has only 3 methods: ```java interface SingleObserver { @@ -119,7 +119,7 @@ and follows the protocol `onSubscribe (onSuccess | onError)?`. # Completable -The `Completable` type remains largely the same. It was already designed along the Reactive-Streams style for 1.x so no user-level changes there. +The `Completable` type remains largely the same. It was already designed along the Reactive Streams style for 1.x so no user-level changes there. Similar to the naming changes, `rx.Completable.CompletableSubscriber` has become `io.reactivex.CompletableObserver` with `onSubscribe(Disposable)`: @@ -154,7 +154,7 @@ Maybe.just(1) # Base reactive interfaces -Following the style of extending the Reactive-Streams `Publisher` in `Flowable`, the other base reactive classes now extend similar base interfaces (in package `io.reactivex`): +Following the style of extending the Reactive Streams `Publisher` in `Flowable`, the other base reactive classes now extend similar base interfaces (in package `io.reactivex`): ```java interface ObservableSource { @@ -182,7 +182,7 @@ Flowable flatMap(Function> mapper Observable flatMap(Function> mapper); ``` -By having `Publisher` as input this way, you can compose with other Reactive-Streams compliant libraries without the need to wrap them or convert them into `Flowable` first. +By having `Publisher` as input this way, you can compose with other Reactive Streams compliant libraries without the need to wrap them or convert them into `Flowable` first. If an operator has to offer a reactive base type, however, the user will receive the full reactive class (as giving out an `XSource` is practically useless as it doesn't have operators on it): @@ -197,7 +197,7 @@ source.compose((Flowable flowable) -> # Subjects and Processors -In the Reactive-Streams specification, the `Subject`-like behavior, namely being a consumer and supplier of events at the same time, is done by the `org.reactivestreams.Processor` interface. As with the `Observable`/`Flowable` split, the backpressure-aware, Reactive-Streams compliant implementations are based on the `FlowableProcessor` class (which extends `Flowable` to give a rich set of instance operators). An important change regarding `Subject`s (and by extension, `FlowableProcessor`) that they no longer support `T -> R` like conversion (that is, input is of type `T` and the output is of type `R`). (We never had a use for it in 1.x and the original `Subject` came from .NET where there is a `Subject` overload because .NET allows the same class name with a different number of type arguments.) +In the Reactive Streams specification, the `Subject`-like behavior, namely being a consumer and supplier of events at the same time, is done by the `org.reactivestreams.Processor` interface. As with the `Observable`/`Flowable` split, the backpressure-aware, Reactive Streams compliant implementations are based on the `FlowableProcessor` class (which extends `Flowable` to give a rich set of instance operators). An important change regarding `Subject`s (and by extension, `FlowableProcessor`) that they no longer support `T -> R` like conversion (that is, input is of type `T` and the output is of type `R`). (We never had a use for it in 1.x and the original `Subject` came from .NET where there is a `Subject` overload because .NET allows the same class name with a different number of type arguments.) The `io.reactivex.subjects.AsyncSubject`, `io.reactivex.subjects.BehaviorSubject`, `io.reactivex.subjects.PublishSubject`, `io.reactivex.subjects.ReplaySubject` and `io.reactivex.subjects.UnicastSubject` in 2.x don't support backpressure (as part of the 2.x `Observable` family). @@ -296,7 +296,7 @@ In addition, operators requiring a predicate no longer use `Func1` b # Subscriber -The Reactive-Streams specification has its own Subscriber as an interface. This interface is lightweight and combines request management with cancellation into a single interface `org.reactivestreams.Subscription` instead of having `rx.Producer` and `rx.Subscription` separately. This allows creating stream consumers with less internal state than the quite heavy `rx.Subscriber` of 1.x. +The Reactive Streams specification has its own Subscriber as an interface. This interface is lightweight and combines request management with cancellation into a single interface `org.reactivestreams.Subscription` instead of having `rx.Producer` and `rx.Subscription` separately. This allows creating stream consumers with less internal state than the quite heavy `rx.Subscriber` of 1.x. ```java Flowable.range(1, 10).subscribe(new Subscriber() { @@ -354,7 +354,7 @@ Flowable.range(1, 10).delay(1, TimeUnit.SECONDS).subscribe(subscriber); subscriber.dispose(); ``` -Note also that due to Reactive-Streams compatibility, the method `onCompleted` has been renamed to `onComplete` without the trailing `d`. +Note also that due to Reactive Streams compatibility, the method `onCompleted` has been renamed to `onComplete` without the trailing `d`. Since 1.x `Observable.subscribe(Subscriber)` returned `Subscription`, users often added the `Subscription` to a `CompositeSubscription` for example: @@ -364,7 +364,7 @@ CompositeSubscription composite = new CompositeSubscription(); composite.add(Observable.range(1, 5).subscribe(new TestSubscriber())); ``` -Due to the Reactive-Streams specification, `Publisher.subscribe` returns void and the pattern by itself no longer works in 2.0. To remedy this, the method `E subscribeWith(E subscriber)` has been added to each base reactive class which returns its input subscriber/observer as is. With the two examples before, the 2.x code can now look like this since `ResourceSubscriber` implements `Disposable` directly: +Due to the Reactive Streams specification, `Publisher.subscribe` returns void and the pattern by itself no longer works in 2.0. To remedy this, the method `E subscribeWith(E subscriber)` has been added to each base reactive class which returns its input subscriber/observer as is. With the two examples before, the 2.x code can now look like this since `ResourceSubscriber` implements `Disposable` directly: ```java CompositeDisposable composite2 = new CompositeDisposable(); @@ -420,11 +420,11 @@ This behavior differs from 1.x where a `request` call went through a deferred lo # Subscription -In RxJava 1.x, the interface `rx.Subscription` was responsible for stream and resource lifecycle management, namely unsubscribing a sequence and releasing general resources such as scheduled tasks. The Reactive-Streams specification took this name for specifying an interaction point between a source and a consumer: `org.reactivestreams.Subscription` allows requesting a positive amount from the upstream and allows cancelling the sequence. +In RxJava 1.x, the interface `rx.Subscription` was responsible for stream and resource lifecycle management, namely unsubscribing a sequence and releasing general resources such as scheduled tasks. The Reactive Streams specification took this name for specifying an interaction point between a source and a consumer: `org.reactivestreams.Subscription` allows requesting a positive amount from the upstream and allows cancelling the sequence. To avoid the name clash, the 1.x `rx.Subscription` has been renamed into `io.reactivex.Disposable` (somewhat resembling .NET's own IDisposable). -Because Reactive-Streams base interface, `org.reactivestreams.Publisher` defines the `subscribe()` method as `void`, `Flowable.subscribe(Subscriber)` no longer returns any `Subscription` (or `Disposable`). The other base reactive types also follow this signature with their respective subscriber types. +Because Reactive Streams base interface, `org.reactivestreams.Publisher` defines the `subscribe()` method as `void`, `Flowable.subscribe(Subscriber)` no longer returns any `Subscription` (or `Disposable`). The other base reactive types also follow this signature with their respective subscriber types. The other overloads of `subscribe` now return `Disposable` in 2.x. @@ -436,19 +436,19 @@ The original `Subscription` container types have been renamed and updated # Backpressure -The Reactive-Streams specification mandates operators supporting backpressure, specifically via the guarantee that they don't overflow their consumers when those don't request. Operators of the new `Flowable` base reactive type now consider downstream request amounts properly, however, this doesn't mean `MissingBackpressureException` is gone. The exception is still there but this time, the operator that can't signal more `onNext` will signal this exception instead (allowing better identification of who is not properly backpressured). +The Reactive Streams specification mandates operators supporting backpressure, specifically via the guarantee that they don't overflow their consumers when those don't request. Operators of the new `Flowable` base reactive type now consider downstream request amounts properly, however, this doesn't mean `MissingBackpressureException` is gone. The exception is still there but this time, the operator that can't signal more `onNext` will signal this exception instead (allowing better identification of who is not properly backpressured). As an alternative, the 2.x `Observable` doesn't do backpressure at all and is available as a choice to switch over. -# Reactive-Streams compliance +# Reactive Streams compliance **updated in 2.0.7** -**The `Flowable`-based sources and operators are, as of 2.0.7, fully Reactive-Streams version 1.0.0 specification compliant.** +**The `Flowable`-based sources and operators are, as of 2.0.7, fully Reactive Streams version 1.0.0 specification compliant.** Before 2.0.7, the operator `strict()` had to be applied in order to achieve the same level of compliance. In 2.0.7, the operator `strict()` returns `this`, is deprecated and will be removed completely in 2.1.0. -As one of the primary goals of RxJava 2, the design focuses on performance and in order enable it, RxJava 2.0.7 adds a custom `io.reactivex.FlowableSubscriber` interface (extends `org.reactivestreams.Subscriber`) but adds no new methods to it. The new interface is **constrained to RxJava 2** and represents a consumer to `Flowable` that is able to work in a mode that relaxes the Reactive-Streams version 1.0.0 specification in rules §1.3, §2.3, §2.12 and §3.9: +As one of the primary goals of RxJava 2, the design focuses on performance and in order enable it, RxJava 2.0.7 adds a custom `io.reactivex.FlowableSubscriber` interface (extends `org.reactivestreams.Subscriber`) but adds no new methods to it. The new interface is **constrained to RxJava 2** and represents a consumer to `Flowable` that is able to work in a mode that relaxes the Reactive Streams version 1.0.0 specification in rules §1.3, §2.3, §2.12 and §3.9: - §1.3 relaxation: `onSubscribe` may run concurrently with `onNext` in case the `FlowableSubscriber` calls `request()` from inside `onSubscribe` and it is the resposibility of `FlowableSubscriber` to ensure thread-safety between the remaining instructions in `onSubscribe` and `onNext`. - §2.3 relaxation: calling `Subscription.cancel` and `Subscription.request` from `FlowableSubscriber.onComplete()` or `FlowableSubscriber.onError()` is considered a no-operation. @@ -603,7 +603,7 @@ Integer i = Flowable.range(100, 100).blockingLast(); (The reason for this is twofold: performance and ease of use of the library as a synchronous Java 8 Streams-like processor.) -Another significant difference between `rx.Subscriber` (and co) and `org.reactivestreams.Subscriber` (and co) is that in 2.x, your `Subscriber`s and `Observer`s are not allowed to throw anything but fatal exceptions (see `Exceptions.throwIfFatal()`). (The Reactive-Streams specification allows throwing `NullPointerException` if the `onSubscribe`, `onNext` or `onError` receives a `null` value, but RxJava doesn't let `null`s in any way.) This means the following code is no longer legal: +Another significant difference between `rx.Subscriber` (and co) and `org.reactivestreams.Subscriber` (and co) is that in 2.x, your `Subscriber`s and `Observer`s are not allowed to throw anything but fatal exceptions (see `Exceptions.throwIfFatal()`). (The Reactive Streams specification allows throwing `NullPointerException` if the `onSubscribe`, `onNext` or `onError` receives a `null` value, but RxJava doesn't let `null`s in any way.) This means the following code is no longer legal: ```java Subscriber subscriber = new Subscriber() { @@ -933,7 +933,7 @@ To make sure the final API of 2.0 is clean as possible, we remove methods and ot ## doOnCancel/doOnDispose/unsubscribeOn -In 1.x, the `doOnUnsubscribe` was always executed on a terminal event because 1.x' `SafeSubscriber` called `unsubscribe` on itself. This was practically unnecessary and the Reactive-Streams specification states that when a terminal event arrives at a `Subscriber`, the upstream `Subscription` should be considered cancelled and thus calling `cancel()` is a no-op. +In 1.x, the `doOnUnsubscribe` was always executed on a terminal event because 1.x' `SafeSubscriber` called `unsubscribe` on itself. This was practically unnecessary and the Reactive Streams specification states that when a terminal event arrives at a `Subscriber`, the upstream `Subscription` should be considered cancelled and thus calling `cancel()` is a no-op. For the same reason, `unsubscribeOn` is not called on the regular termination path but only when there is an actual `cancel` (or `dispose`) call on the chain. diff --git a/docs/What's-different-in-3.0.md b/docs/What's-different-in-3.0.md new file mode 100644 index 0000000000..e936692c06 --- /dev/null +++ b/docs/What's-different-in-3.0.md @@ -0,0 +1,33 @@ +Table of contents + +# Introduction +TBD. + +### API signature changes + +TBD. + +- as() merged into to() +- some operators returning a more appropriate Single or Maybe +- functional interfaces throws widening to Throwable +- standard methods removed +- standard methods signature changes + +### Standardized operators + +(former experimental and beta operators from 2.x) + +TBD. + +### Operator behavior changes + +TBD. + +- connectable sources lifecycle-fixes + + +### Test support changes + +TBD. + +- methods removed from the test consumers diff --git a/docs/Writing-operators-for-2.0.md b/docs/Writing-operators-for-2.0.md index 7b6e57666e..9649c02be7 100644 --- a/docs/Writing-operators-for-2.0.md +++ b/docs/Writing-operators-for-2.0.md @@ -40,7 +40,7 @@ Writing operators, source-like (`fromEmitter`) or intermediate-like (`flatMap`) *(If you have been following [my blog](http://akarnokd.blogspot.hu/) about RxJava internals, writing operators is maybe only 2 times harder than 1.x; some things have moved around, some tools popped up while others have been dropped but there is a relatively straight mapping from 1.x concepts and approaches to 2.x concepts and approaches.)* -In this article, I'll describe the how-to's from the perspective of a developer who skipped the 1.x knowledge base and basically wants to write operators that conforms the Reactive-Streams specification as well as RxJava 2.x's own extensions and additional expectations/requirements. +In this article, I'll describe the how-to's from the perspective of a developer who skipped the 1.x knowledge base and basically wants to write operators that conforms the Reactive Streams specification as well as RxJava 2.x's own extensions and additional expectations/requirements. Since **Reactor 3** has the same architecture as **RxJava 2** (no accident, I architected and contributed 80% of **Reactor 3** as well) the same principles outlined in this page applies to writing operators for **Reactor 3**. Note however that they chose different naming and locations for their utility and support classes so you may have to search for the equivalent components. @@ -66,7 +66,7 @@ When dealing with backpressure in `Flowable` operators, one needs a way to accou The naive approach for accounting would be to simply call `AtomicLong.getAndAdd()` with new requests and `AtomicLong.addAndGet()` for decrementing based on how many elements were emitted. -The problem with this is that the Reactive-Streams specification declares `Long.MAX_VALUE` as the upper bound for outstanding requests (interprets it as the unbounded mode) but adding two large longs may overflow the `long` into a negative value. In addition, if for some reason, there are more values emitted than were requested, the subtraction may yield a negative current request value, causing crashes or hangs. +The problem with this is that the Reactive Streams specification declares `Long.MAX_VALUE` as the upper bound for outstanding requests (interprets it as the unbounded mode) but adding two large longs may overflow the `long` into a negative value. In addition, if for some reason, there are more values emitted than were requested, the subtraction may yield a negative current request value, causing crashes or hangs. Therefore, both addition and subtraction have to be capped at `Long.MAX_VALUE` and `0` respectively. Since there is no dedicated `AtomicLong` method for it, we have to use a Compare-And-Set loop. (Usually, requesting happens relatively rarely compared to emission amounts thus the lack of dedicated machine code instruction is not a performance bottleneck.) @@ -225,7 +225,7 @@ This simplified queue API gets rid of the unused parts (iterator, collections AP ## Deferred actions -The Reactive-Streams has a strict requirement that calling `onSubscribe()` must happen before any calls to the rest of the `onXXX` methods and by nature, any calls to `Subscription.request()` and `Subscription.cancel()`. The same logic applies to the design of `Observable`, `Single`, `Completable` and `Maybe` with their connection type of `Disposable`. +The Reactive Streams has a strict requirement that calling `onSubscribe()` must happen before any calls to the rest of the `onXXX` methods and by nature, any calls to `Subscription.request()` and `Subscription.cancel()`. The same logic applies to the design of `Observable`, `Single`, `Completable` and `Maybe` with their connection type of `Disposable`. Often though, such call to `onSubscribe` may happen later than the respective `cancel()` needs to happen. For example, the user may want to call `cancel()` before the respective `Subscription` actually becomes available in `subscribeOn`. Other operators may need to call `onSubscribe` before they connect to other sources but at that time, there is no direct way for relaying a `cancel` call to an unavailable upstream `Subscription`. @@ -286,7 +286,7 @@ The same pattern applies to `Subscription` with its `cancel()` method and with h ### Deferred requesting -With `Flowable`s (and Reactive-Streams `Publisher`s) the `request()` calls need to be deferred as well. In one form (the simpler one), the respective late `Subscription` will eventually arrive and we need to relay all previous and all subsequent request amount to its `request()` method. +With `Flowable`s (and Reactive Streams `Publisher`s) the `request()` calls need to be deferred as well. In one form (the simpler one), the respective late `Subscription` will eventually arrive and we need to relay all previous and all subsequent request amount to its `request()` method. In 1.x, this behavior was implicitly provided by `rx.Subscriber` but at a high cost that had to be payed by all instances whether or not they needed this feature. @@ -561,7 +561,7 @@ On the fast path, when we try to leave it, it is possible a concurrent call to ` ## FlowableSubscriber -Version 2.0.7 introduced a new interface, `FlowableSubscriber` that extends `Subscriber` from Reactive-Streams. It has the same methods with the same parameter types but different textual rules attached to it, a set of relaxations to the Reactive-Streams specification to enable better performing RxJava internals while still honoring the specification to the letter for non-RxJava consumers of `Flowable`s. +Version 2.0.7 introduced a new interface, `FlowableSubscriber` that extends `Subscriber` from Reactive Streams. It has the same methods with the same parameter types but different textual rules attached to it, a set of relaxations to the Reactive Streams specification to enable better performing RxJava internals while still honoring the specification to the letter for non-RxJava consumers of `Flowable`s. The rule relaxations are as follows: @@ -588,7 +588,7 @@ The other base reactive consumers, `Observer`, `SingleObserver`, `MaybeObserver` # Backpressure and cancellation -Backpressure (or flow control) in Reactive-Streams is the means to tell the upstream how many elements to produce or to tell it to stop producing elements altogether. Unlike the name suggest, there is no physical pressure preventing the upstream from calling `onNext` but the protocol to honor the request amount. +Backpressure (or flow control) in Reactive Streams is the means to tell the upstream how many elements to produce or to tell it to stop producing elements altogether. Unlike the name suggest, there is no physical pressure preventing the upstream from calling `onNext` but the protocol to honor the request amount. ## Replenishing @@ -1425,7 +1425,7 @@ public final class FlowableMyOperator extends Flowable { } ``` -When taking other reactive types as inputs in these operators, it is recommended one defines the base reactive interfaces instead of the abstract classes, allowing better interoperability between libraries (especially with `Flowable` operators and other Reactive-Streams `Publisher`s). To recap, these are the class-interface pairs: +When taking other reactive types as inputs in these operators, it is recommended one defines the base reactive interfaces instead of the abstract classes, allowing better interoperability between libraries (especially with `Flowable` operators and other Reactive Streams `Publisher`s). To recap, these are the class-interface pairs: - `Flowable` - `Publisher` - `FlowableSubscriber`/`Subscriber` - `Observable` - `ObservableSource` - `Observer` @@ -1433,7 +1433,7 @@ When taking other reactive types as inputs in these operators, it is recommended - `Completable` - `CompletableSource` - `CompletableObserver` - `Maybe` - `MaybeSource` - `MaybeObserver` -RxJava 2.x locks down `Flowable.subscribe` (and the same methods in the other types) in order to provide runtime hooks into the various flows, therefore, implementors are given the `subscribeActual()` to be overridden. When it is invoked, all relevant hooks and wrappers have been applied. Implementors should avoid throwing unchecked exceptions as the library generally can't deliver it to the respective `Subscriber` due to lifecycle restrictions of the Reactive-Streams specification and sends it to the global error consumer via `RxJavaPlugins.onError`. +RxJava 2.x locks down `Flowable.subscribe` (and the same methods in the other types) in order to provide runtime hooks into the various flows, therefore, implementors are given the `subscribeActual()` to be overridden. When it is invoked, all relevant hooks and wrappers have been applied. Implementors should avoid throwing unchecked exceptions as the library generally can't deliver it to the respective `Subscriber` due to lifecycle restrictions of the Reactive Streams specification and sends it to the global error consumer via `RxJavaPlugins.onError`. Unlike in 1.x, In the example above, the incoming `Subscriber` is simply used directly for subscribing again (but still at most once) without any kind of wrapping. In 1.x, one needs to call `Subscribers.wrap` to avoid double calls to `onStart` and cause unexpected double initialization or double-requesting. @@ -1516,7 +1516,7 @@ public final class MyOperator implements FlowableOperator { You may recognize that implementing operators via extension or lifting looks quite similar. In both cases, one usually implements a `FlowableSubscriber` (`Observer`, etc) that takes a downstream `Subscriber`, implements the business logic in the `onXXX` methods and somehow (manually or as part of `lift()`'s lifecycle) gets subscribed to an upstream source. -The benefit of applying the Reactive-Streams design to all base reactive types is that each consumer type is now an interface and can be applied to operators that have to extend some class. This was a pain in 1.x because `Subscriber` and `SingleSubscriber` are classes themselves, plus `Subscriber.request()` is a protected-final method and an operator's `Subscriber` can't implement the `Producer` interface at the same time. In 2.x there is no such problem and one can have both `Subscriber`, `Subscription` or even `Observer` together in the same consumer type. +The benefit of applying the Reactive Streams design to all base reactive types is that each consumer type is now an interface and can be applied to operators that have to extend some class. This was a pain in 1.x because `Subscriber` and `SingleSubscriber` are classes themselves, plus `Subscriber.request()` is a protected-final method and an operator's `Subscriber` can't implement the `Producer` interface at the same time. In 2.x there is no such problem and one can have both `Subscriber`, `Subscription` or even `Observer` together in the same consumer type. # Operator fusion @@ -1569,12 +1569,12 @@ This is the level of the **Rx.NET** library (even up to 3.x) that supports compo This is what **RxJava 1.x** is categorized, it supports composition, backpressure and synchronous cancellation along with the ability to lift an operator into a sequence. #### Generation 3 -This is the level of the Reactive-Streams based libraries such as **Reactor 2** and **Akka-Stream**. They are based upon a specification that evolved out of RxJava but left behind its drawbacks (such as the need to return anything from `subscribe()`). This is incompatible with RxJava 1.x and thus 2.x had to be rewritten from scratch. +This is the level of the Reactive Streams based libraries such as **Reactor 2** and **Akka-Stream**. They are based upon a specification that evolved out of RxJava but left behind its drawbacks (such as the need to return anything from `subscribe()`). This is incompatible with RxJava 1.x and thus 2.x had to be rewritten from scratch. #### Generation 4 -This level expands upon the Reactive-Streams interfaces with operator-fusion (in a compatible fashion, that is, op-fusion is optional between two stages and works without them). **Reactor 3** and **RxJava 2** are at this level. The material around **Akka-Stream** mentions operator-fusion as well, however, **Akka-Stream** is not a native Reactive-Streams implementation (requires a materializer to get a `Publisher` out) and as such it is only Gen 3. +This level expands upon the Reactive Streams interfaces with operator-fusion (in a compatible fashion, that is, op-fusion is optional between two stages and works without them). **Reactor 3** and **RxJava 2** are at this level. The material around **Akka-Stream** mentions operator-fusion as well, however, **Akka-Stream** is not a native Reactive Streams implementation (requires a materializer to get a `Publisher` out) and as such it is only Gen 3. -There are discussions among the 4th generation library providers to have the elements of operator-fusion standardized in Reactive-Streams 2.0 specification (or in a neighboring extension) and have **RxJava 3** and **Reactor 4** work together on that aspect as well. +There are discussions among the 4th generation library providers to have the elements of operator-fusion standardized in Reactive Streams 2.0 specification (or in a neighboring extension) and have **RxJava 3** and **Reactor 4** work together on that aspect as well. ## Components @@ -1629,7 +1629,7 @@ The reason for the two separate interfaces is that if a source is constant, like `Callable` denotes sources, such as `fromCallable` that indicates the single value has to be calculated at runtime of the flow. By this logic, you can see that `ScalarCallable` is a `Callable` on its own right because the constant can be "calculated" as late as the runtime phase of the flow. -Since Reactive-Streams forbids using `null`s as emission values, we can use `null` in `(Scalar)Callable` marked sources to indicate there is no value to be emitted, thus one can't mistake an user's `null` with the empty indicator `null`. For example, this is how `empty()` is implemented: +Since Reactive Streams forbids using `null`s as emission values, we can use `null` in `(Scalar)Callable` marked sources to indicate there is no value to be emitted, thus one can't mistake an user's `null` with the empty indicator `null`. For example, this is how `empty()` is implemented: ```java final class FlowableEmpty extends Flowable implements ScalarCallable { diff --git a/gradle/javadoc_cleanup.gradle b/gradle/javadoc_cleanup.gradle index 79f4d5411a..518d7a1d51 100644 --- a/gradle/javadoc_cleanup.gradle +++ b/gradle/javadoc_cleanup.gradle @@ -12,6 +12,8 @@ task javadocCleanup(dependsOn: "javadoc") doLast { fixJavadocFile(rootProject.file('build/docs/javadoc/io/reactivex/subjects/ReplaySubject.html')); fixJavadocFile(rootProject.file('build/docs/javadoc/io/reactivex/processors/ReplayProcessor.html')); fixJavadocFile(rootProject.file('build/docs/javadoc/io/reactivex/plugins/RxJavaPlugins.html')); + + fixJavadocFile(rootProject.file('build/docs/javadoc/io/reactivex/parallel/ParallelFlowable.html')); } def fixJavadocFile(file) { diff --git a/src/main/java/io/reactivex/Completable.java b/src/main/java/io/reactivex/Completable.java index 948d8aecde..1994632307 100644 --- a/src/main/java/io/reactivex/Completable.java +++ b/src/main/java/io/reactivex/Completable.java @@ -118,6 +118,7 @@ public abstract class Completable implements CompletableSource { * @throws NullPointerException if sources is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable ambArray(final CompletableSource... sources) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -146,6 +147,7 @@ public static Completable ambArray(final CompletableSource... sources) { * @throws NullPointerException if sources is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable amb(final Iterable sources) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -164,6 +166,7 @@ public static Completable amb(final Iterable source * @return a Completable instance that completes immediately */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable complete() { return RxJavaPlugins.onAssembly(CompletableEmpty.INSTANCE); @@ -182,6 +185,7 @@ public static Completable complete() { * @throws NullPointerException if sources is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable concatArray(CompletableSource... sources) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -207,6 +211,7 @@ public static Completable concatArray(CompletableSource... sources) { * @throws NullPointerException if sources is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable concat(Iterable sources) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -253,6 +258,7 @@ public static Completable concat(Publisher sources) * @throws NullPointerException if sources is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) @BackpressureSupport(BackpressureKind.FULL) public static Completable concat(Publisher sources, int prefetch) { @@ -297,6 +303,7 @@ public static Completable concat(Publisher sources, * @see Cancellable */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable create(CompletableOnSubscribe source) { ObjectHelper.requireNonNull(source, "source is null"); @@ -319,6 +326,7 @@ public static Completable create(CompletableOnSubscribe source) { * @throws NullPointerException if source is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable unsafeCreate(CompletableSource source) { ObjectHelper.requireNonNull(source, "source is null"); @@ -340,6 +348,7 @@ public static Completable unsafeCreate(CompletableSource source) { * @return the Completable instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable defer(final Callable completableSupplier) { ObjectHelper.requireNonNull(completableSupplier, "completableSupplier"); @@ -363,6 +372,7 @@ public static Completable defer(final Callable comp * @throws NullPointerException if errorSupplier is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable error(final Callable errorSupplier) { ObjectHelper.requireNonNull(errorSupplier, "errorSupplier is null"); @@ -382,6 +392,7 @@ public static Completable error(final Callable errorSupplie * @throws NullPointerException if error is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable error(final Throwable error) { ObjectHelper.requireNonNull(error, "error is null"); @@ -409,6 +420,7 @@ public static Completable error(final Throwable error) { * @throws NullPointerException if run is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable fromAction(final Action run) { ObjectHelper.requireNonNull(run, "run is null"); @@ -435,6 +447,7 @@ public static Completable fromAction(final Action run) { * @return the new Completable instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable fromCallable(final Callable callable) { ObjectHelper.requireNonNull(callable, "callable is null"); @@ -455,6 +468,7 @@ public static Completable fromCallable(final Callable callable) { * @return the new Completable instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable fromFuture(final Future future) { ObjectHelper.requireNonNull(future, "future is null"); @@ -479,6 +493,7 @@ public static Completable fromFuture(final Future future) { * @since 2.2 */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable fromMaybe(final MaybeSource maybe) { ObjectHelper.requireNonNull(maybe, "maybe is null"); @@ -493,12 +508,20 @@ public static Completable fromMaybe(final MaybeSource maybe) { *
*
Scheduler:
*
{@code fromRunnable} does not operate by default on a particular {@link Scheduler}.
+ *
Error handling:
+ *
If the {@link Runnable} throws an exception, the respective {@link Throwable} is + * delivered to the downstream via {@link CompletableObserver#onError(Throwable)}, + * except when the downstream has disposed this {@code Completable} source. + * In this latter case, the {@code Throwable} is delivered to the global error handler via + * {@link RxJavaPlugins#onError(Throwable)} as an {@link io.reactivex.exceptions.UndeliverableException UndeliverableException}. + *
*
* @param run the runnable to run for each subscriber * @return the new Completable instance * @throws NullPointerException if run is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable fromRunnable(final Runnable run) { ObjectHelper.requireNonNull(run, "run is null"); @@ -520,6 +543,7 @@ public static Completable fromRunnable(final Runnable run) { * @throws NullPointerException if flowable is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable fromObservable(final ObservableSource observable) { ObjectHelper.requireNonNull(observable, "observable is null"); @@ -533,7 +557,7 @@ public static Completable fromObservable(final ObservableSource observabl * *

* The {@link Publisher} must follow the - * Reactive-Streams specification. + * Reactive Streams specification. * Violating the specification may result in undefined behavior. *

* If possible, use {@link #create(CompletableOnSubscribe)} to create a @@ -556,6 +580,7 @@ public static Completable fromObservable(final ObservableSource observabl * @see #create(CompletableOnSubscribe) */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public static Completable fromPublisher(final Publisher publisher) { @@ -578,6 +603,7 @@ public static Completable fromPublisher(final Publisher publisher) { * @throws NullPointerException if single is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable fromSingle(final SingleSource single) { ObjectHelper.requireNonNull(single, "single is null"); @@ -612,6 +638,7 @@ public static Completable fromSingle(final SingleSource single) { * @see #mergeArrayDelayError(CompletableSource...) */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable mergeArray(CompletableSource... sources) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -652,6 +679,7 @@ public static Completable mergeArray(CompletableSource... sources) { * @see #mergeDelayError(Iterable) */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable merge(Iterable sources) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -753,6 +781,7 @@ public static Completable merge(Publisher sources, * @throws IllegalArgumentException if maxConcurrency is less than 1 */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) @BackpressureSupport(BackpressureKind.FULL) private static Completable merge0(Publisher sources, int maxConcurrency, boolean delayErrors) { @@ -776,6 +805,7 @@ private static Completable merge0(Publisher sources * @throws NullPointerException if sources is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable mergeArrayDelayError(CompletableSource... sources) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -797,6 +827,7 @@ public static Completable mergeArrayDelayError(CompletableSource... sources) { * @throws NullPointerException if sources is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable mergeDelayError(Iterable sources) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -902,6 +933,7 @@ public static Completable timer(long delay, TimeUnit unit) { * @return the new Completable instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.CUSTOM) public static Completable timer(final long delay, final TimeUnit unit, final Scheduler scheduler) { ObjectHelper.requireNonNull(unit, "unit is null"); @@ -968,6 +1000,7 @@ public static Completable using(Callable resourceSupplier, * @return the new Completable instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable using( final Callable resourceSupplier, @@ -995,6 +1028,7 @@ public static Completable using( * @throws NullPointerException if source is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Completable wrap(CompletableSource source) { ObjectHelper.requireNonNull(source, "source is null"); @@ -1019,6 +1053,7 @@ public static Completable wrap(CompletableSource source) { * @throws NullPointerException if other is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Completable ambWith(CompletableSource other) { ObjectHelper.requireNonNull(other, "other is null"); @@ -1042,6 +1077,7 @@ public final Completable ambWith(CompletableSource other) { * @throws NullPointerException if next is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Observable andThen(ObservableSource next) { ObjectHelper.requireNonNull(next, "next is null"); @@ -1068,6 +1104,7 @@ public final Observable andThen(ObservableSource next) { * @throws NullPointerException if next is null */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable andThen(Publisher next) { @@ -1092,6 +1129,7 @@ public final Flowable andThen(Publisher next) { * @return Single that composes this Completable and next */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Single andThen(SingleSource next) { ObjectHelper.requireNonNull(next, "next is null"); @@ -1115,6 +1153,7 @@ public final Single andThen(SingleSource next) { * @return Maybe that composes this Completable and next */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe andThen(MaybeSource next) { ObjectHelper.requireNonNull(next, "next is null"); @@ -1139,7 +1178,8 @@ public final Maybe andThen(MaybeSource next) { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Completable andThen(CompletableSource next) { - return concatWith(next); + ObjectHelper.requireNonNull(next, "next is null"); + return RxJavaPlugins.onAssembly(new CompletableAndThenCompletable(this, next)); } /** @@ -1207,6 +1247,7 @@ public final void blockingAwait() { * @throws RuntimeException wrapping an InterruptedException if the current thread is interrupted */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final boolean blockingAwait(long timeout, TimeUnit unit) { ObjectHelper.requireNonNull(unit, "unit is null"); @@ -1320,10 +1361,11 @@ public final Completable compose(CompletableTransformer transformer) { * @see #andThen(Publisher) */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Completable concatWith(CompletableSource other) { ObjectHelper.requireNonNull(other, "other is null"); - return concatArray(this, other); + return RxJavaPlugins.onAssembly(new CompletableAndThenCompletable(this, other)); } /** @@ -1383,6 +1425,7 @@ public final Completable delay(long delay, TimeUnit unit, Scheduler scheduler) { * @throws NullPointerException if unit or scheduler is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.CUSTOM) public final Completable delay(final long delay, final TimeUnit unit, final Scheduler scheduler, final boolean delayError) { ObjectHelper.requireNonNull(unit, "unit is null"); @@ -1514,6 +1557,7 @@ public final Completable doOnError(Consumer onError) { * @throws NullPointerException if onEvent is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Completable doOnEvent(final Consumer onEvent) { ObjectHelper.requireNonNull(onEvent, "onEvent is null"); @@ -1535,6 +1579,7 @@ public final Completable doOnEvent(final Consumer onEvent) { * @return the new Completable instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) private Completable doOnLifecycle( final Consumer onSubscribe, @@ -1639,6 +1684,7 @@ public final Completable doAfterTerminate(final Action onAfterTerminate) { * @since 2.1 */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Completable doFinally(Action onFinally) { ObjectHelper.requireNonNull(onFinally, "onFinally is null"); @@ -1776,6 +1822,7 @@ public final Completable doFinally(Action onFinally) { * @see #compose(CompletableTransformer) */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Completable lift(final CompletableOperator onLift) { ObjectHelper.requireNonNull(onLift, "onLift is null"); @@ -1817,6 +1864,7 @@ public final Single> materialize() { * @throws NullPointerException if other is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Completable mergeWith(CompletableSource other) { ObjectHelper.requireNonNull(other, "other is null"); @@ -1836,6 +1884,7 @@ public final Completable mergeWith(CompletableSource other) { * @throws NullPointerException if scheduler is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.CUSTOM) public final Completable observeOn(final Scheduler scheduler) { ObjectHelper.requireNonNull(scheduler, "scheduler is null"); @@ -1873,6 +1922,7 @@ public final Completable onErrorComplete() { * @return the new Completable instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Completable onErrorComplete(final Predicate predicate) { ObjectHelper.requireNonNull(predicate, "predicate is null"); @@ -1895,6 +1945,7 @@ public final Completable onErrorComplete(final Predicate pred * @return the new Completable instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Completable onErrorResumeNext(final Function errorMapper) { ObjectHelper.requireNonNull(errorMapper, "errorMapper is null"); @@ -2039,7 +2090,7 @@ public final Completable retry(BiPredicate p *

Scheduler:
*
{@code retry} does not operate by default on a particular {@link Scheduler}.
* - * @param times the number of times the returned Completable should retry this Completable + * @param times the number of times to resubscribe if the current Completable fails * @return the new Completable instance * @throws IllegalArgumentException if times is negative */ @@ -2059,7 +2110,7 @@ public final Completable retry(long times) { *
{@code retry} does not operate by default on a particular {@link Scheduler}.
* *

History: 2.1.8 - experimental - * @param times the number of times the returned Completable should retry this Completable + * @param times the number of times to resubscribe if the current Completable fails * @param predicate the predicate that is called with the latest throwable and should return * true to indicate the returned Completable should resubscribe to this Completable. * @return the new Completable instance @@ -2153,6 +2204,7 @@ public final Completable retryWhen(Function, ? exten * @throws NullPointerException if other is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Completable startWith(CompletableSource other) { ObjectHelper.requireNonNull(other, "other is null"); @@ -2174,6 +2226,7 @@ public final Completable startWith(CompletableSource other) { * @throws NullPointerException if other is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Observable startWith(Observable other) { ObjectHelper.requireNonNull(other, "other is null"); @@ -2197,6 +2250,7 @@ public final Observable startWith(Observable other) { * @throws NullPointerException if other is null */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable startWith(Publisher other) { @@ -2245,7 +2299,7 @@ public final Disposable subscribe() { @SchedulerSupport(SchedulerSupport.NONE) @Override public final void subscribe(CompletableObserver observer) { - ObjectHelper.requireNonNull(observer, "s is null"); + ObjectHelper.requireNonNull(observer, "observer is null"); try { observer = RxJavaPlugins.onSubscribe(this, observer); @@ -2319,6 +2373,7 @@ public final E subscribeWith(E observer) { * @throws NullPointerException if either callback is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Disposable subscribe(final Action onComplete, final Consumer onError) { ObjectHelper.requireNonNull(onError, "onError is null"); @@ -2346,6 +2401,7 @@ public final Disposable subscribe(final Action onComplete, final Consumer Observable toObservable() { * @throws NullPointerException if completionValueSupplier is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Single toSingle(final Callable completionValueSupplier) { ObjectHelper.requireNonNull(completionValueSupplier, "completionValueSupplier is null"); @@ -2646,6 +2708,7 @@ public final Single toSingle(final Callable completionValueS * @throws NullPointerException if completionValue is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Single toSingleDefault(final T completionValue) { ObjectHelper.requireNonNull(completionValue, "completionValue is null"); @@ -2666,6 +2729,7 @@ public final Single toSingleDefault(final T completionValue) { * @throws NullPointerException if scheduler is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.CUSTOM) public final Completable unsubscribeOn(final Scheduler scheduler) { ObjectHelper.requireNonNull(scheduler, "scheduler is null"); diff --git a/src/main/java/io/reactivex/Flowable.java b/src/main/java/io/reactivex/Flowable.java index 1115eba74e..41cde991a7 100644 --- a/src/main/java/io/reactivex/Flowable.java +++ b/src/main/java/io/reactivex/Flowable.java @@ -17,7 +17,6 @@ import org.reactivestreams.*; -import io.reactivex.Observable; import io.reactivex.annotations.*; import io.reactivex.disposables.Disposable; import io.reactivex.exceptions.Exceptions; @@ -37,12 +36,12 @@ import io.reactivex.subscribers.*; /** - * The Flowable class that implements the Reactive-Streams Pattern and offers factory methods, - * intermediate operators and the ability to consume reactive dataflows. + * The Flowable class that implements the Reactive Streams + * Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows. *

- * Reactive-Streams operates with {@code Publisher}s which {@code Flowable} extends. Many operators + * Reactive Streams operates with {@link Publisher}s which {@code Flowable} extends. Many operators * therefore accept general {@code Publisher}s directly and allow direct interoperation with other - * Reactive-Streams implementations. + * Reactive Streams implementations. *

* The Flowable hosts the default buffer size of 128 elements for operators, accessible via {@link #bufferSize()}, * that can be overridden globally via the system parameter {@code rx2.buffer-size}. Most operators, however, have @@ -52,11 +51,103 @@ *

* *

+ * The {@code Flowable} follows the protocol + * 


+ *      onSubscribe onNext* (onError | onComplete)?
+ *
+ * where the stream can be disposed through the {@link Subscription} instance provided to consumers through + * {@link Subscriber#onSubscribe(Subscription)}. + * Unlike the {@code Observable.subscribe()} of version 1.x, {@link #subscribe(Subscriber)} does not allow external cancellation + * of a subscription and the {@link Subscriber} instance is expected to expose such capability if needed. + *

+ * Flowables support backpressure and require {@link Subscriber}s to signal demand via {@link Subscription#request(long)}. + *

+ * Example: + * 


+ * Disposable d = Flowable.just("Hello world!")
+ *     .delay(1, TimeUnit.SECONDS)
+ *     .subscribeWith(new DisposableSubscriber<String>() {
+ *         @Override public void onStart() {
+ *             System.out.println("Start!");
+ *             request(1);
+ *         }
+ *         @Override public void onNext(String t) {
+ *             System.out.println(t);
+ *             request(1);
+ *         }
+ *         @Override public void onError(Throwable t) {
+ *             t.printStackTrace();
+ *         }
+ *         @Override public void onComplete() {
+ *             System.out.println("Done!");
+ *         }
+ *     });
+ *
+ * Thread.sleep(500);
+ * // the sequence can now be cancelled via dispose()
+ * d.dispose();
+ *
+ *

+ * The Reactive Streams specification is relatively strict when defining interactions between {@code Publisher}s and {@code Subscriber}s, so much so + * that there is a significant performance penalty due certain timing requirements and the need to prepare for invalid + * request amounts via {@link Subscription#request(long)}. + * Therefore, RxJava has introduced the {@link FlowableSubscriber} interface that indicates the consumer can be driven with relaxed rules. + * All RxJava operators are implemented with these relaxed rules in mind. + * If the subscribing {@code Subscriber} does not implement this interface, for example, due to it being from another Reactive Streams compliant + * library, the Flowable will automatically apply a compliance wrapper around it. + *

+ * {@code Flowable} is an abstract class, but it is not advised to implement sources and custom operators by extending the class directly due + * to the large amounts of Reactive Streams + * rules to be followed to the letter. See the wiki for + * some guidance if such custom implementations are necessary. + *

+ * The recommended way of creating custom {@code Flowable}s is by using the {@link #create(FlowableOnSubscribe, BackpressureStrategy)} factory method: + * 


+ * Flowable<String> source = Flowable.create(new FlowableOnSubscribe<String>() {
+ *     @Override
+ *     public void subscribe(FlowableEmitter<String> emitter) throws Exception {
+ *
+ *         // signal an item
+ *         emitter.onNext("Hello");
+ *
+ *         // could be some blocking operation
+ *         Thread.sleep(1000);
+ *
+ *         // the consumer might have cancelled the flow
+ *         if (emitter.isCancelled() {
+ *             return;
+ *         }
+ *
+ *         emitter.onNext("World");
+ *
+ *         Thread.sleep(1000);
+ *
+ *         // the end-of-sequence has to be signaled, otherwise the
+ *         // consumers may never finish
+ *         emitter.onComplete();
+ *     }
+ * }, BackpressureStrategy.BUFFER);
+ *
+ * System.out.println("Subscribe!");
+ * 
+ * source.subscribe(System.out::println);
+ * 
+ * System.out.println("Done!");
+ *
+ *

+ * RxJava reactive sources, such as {@code Flowable}, are generally synchronous and sequential in nature. In the ReactiveX design, the location (thread) + * where operators run is orthogonal to when the operators can work with data. This means that asynchrony and parallelism + * has to be explicitly expressed via operators such as {@link #subscribeOn(Scheduler)}, {@link #observeOn(Scheduler)} and {@link #parallel()}. In general, + * operators featuring a {@link Scheduler} parameter are introducing this type of asynchrony into the flow. + *

* For more information see the ReactiveX * documentation. * * @param * the type of the items emitted by the Flowable + * @see Observable + * @see ParallelFlowable + * @see io.reactivex.subscribers.DisposableSubscriber */ public abstract class Flowable implements Publisher { /** The default buffer size. */ @@ -87,6 +178,7 @@ public abstract class Flowable implements Publisher { * @see ReactiveX operators documentation: Amb */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable amb(Iterable> sources) { @@ -116,6 +208,7 @@ public static Flowable amb(Iterable> sou * @see ReactiveX operators documentation: Amb */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable ambArray(Publisher... sources) { @@ -269,6 +362,7 @@ public static Flowable combineLatest(Function Flowable combineLatest(Publisher[] sources, Function combiner, int bufferSize) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -366,6 +460,7 @@ public static Flowable combineLatest(Iterable Flowable combineLatest(Iterable> sources, Function combiner, int bufferSize) { @@ -556,6 +651,7 @@ public static Flowable combineLatestDelayError(Function Flowable combineLatestDelayError(Publisher[] sources, Function combiner, int bufferSize) { @@ -747,6 +843,7 @@ public static Flowable combineLatest( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable combineLatest( @@ -799,6 +896,7 @@ public static Flowable combineLatest( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable combineLatest( @@ -855,6 +953,7 @@ public static Flowable combineLatest( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable combineLatest( @@ -916,6 +1015,7 @@ public static Flowable combineLatest( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable combineLatest( @@ -981,6 +1081,7 @@ public static Flowable combineLatest( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable combineLatest( @@ -1051,6 +1152,7 @@ public static Flowable combineLatest( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable combineLatest( @@ -1125,6 +1227,7 @@ public static Flowable combineLatest( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable combineLatest( @@ -1166,6 +1269,7 @@ public static Flowable combineLatest( */ @SuppressWarnings({ "unchecked", "rawtypes" }) @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable concat(Iterable> sources) { @@ -1261,6 +1365,7 @@ public static Flowable concat(Publisher> */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable concat(Publisher source1, Publisher source2) { @@ -1297,6 +1402,7 @@ public static Flowable concat(Publisher source1, Publisher Flowable concat( @@ -1338,6 +1444,7 @@ public static Flowable concat( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable concat( @@ -1470,6 +1577,7 @@ public static Flowable concatArrayEager(Publisher... sources * @since 2.0 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings({ "rawtypes", "unchecked" }) @@ -1564,6 +1672,7 @@ public static Flowable concatArrayEagerDelayError(int maxConcurrency, int */ @SuppressWarnings({ "unchecked", "rawtypes" }) @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable concatDelayError(Iterable> sources) { @@ -1668,6 +1777,7 @@ public static Flowable concatEager(Publisher Flowable concatEager(Iterable Flowable concatEager(Iterable Flowable create(FlowableOnSubscribe source, BackpressureStrategy mode) { @@ -1820,6 +1932,7 @@ public static Flowable create(FlowableOnSubscribe source, Backpressure * @see ReactiveX operators documentation: Defer */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable defer(Callable> supplier) { @@ -1874,10 +1987,11 @@ public static Flowable empty() { * @see ReactiveX operators documentation: Throw */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable error(Callable supplier) { - ObjectHelper.requireNonNull(supplier, "errorSupplier is null"); + ObjectHelper.requireNonNull(supplier, "supplier is null"); return RxJavaPlugins.onAssembly(new FlowableError(supplier)); } @@ -1902,6 +2016,7 @@ public static Flowable error(Callable supplier) { * @see ReactiveX operators documentation: Throw */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable error(final Throwable throwable) { @@ -1929,6 +2044,7 @@ public static Flowable error(final Throwable throwable) { * @see ReactiveX operators documentation: From */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable fromArray(T... items) { @@ -1974,6 +2090,7 @@ public static Flowable fromArray(T... items) { * @since 2.0 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable fromCallable(Callable supplier) { @@ -2010,6 +2127,7 @@ public static Flowable fromCallable(Callable supplier) { * @see ReactiveX operators documentation: From */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable fromFuture(Future future) { @@ -2050,6 +2168,7 @@ public static Flowable fromFuture(Future future) { * @see ReactiveX operators documentation: From */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable fromFuture(Future future, long timeout, TimeUnit unit) { @@ -2095,6 +2214,7 @@ public static Flowable fromFuture(Future future, long timeou */ @SuppressWarnings({ "unchecked", "cast" }) @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.CUSTOM) public static Flowable fromFuture(Future future, long timeout, TimeUnit unit, Scheduler scheduler) { @@ -2133,6 +2253,7 @@ public static Flowable fromFuture(Future future, long timeou */ @SuppressWarnings({ "cast", "unchecked" }) @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.CUSTOM) public static Flowable fromFuture(Future future, Scheduler scheduler) { @@ -2161,6 +2282,7 @@ public static Flowable fromFuture(Future future, Scheduler s * @see ReactiveX operators documentation: From */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable fromIterable(Iterable source) { @@ -2169,11 +2291,11 @@ public static Flowable fromIterable(Iterable source) { } /** - * Converts an arbitrary Reactive-Streams Publisher into a Flowable if not already a + * Converts an arbitrary Reactive Streams Publisher into a Flowable if not already a * Flowable. *

* The {@link Publisher} must follow the - * Reactive-Streams specification. + * Reactive Streams specification. * Violating the specification may result in undefined behavior. *

* If possible, use {@link #create(FlowableOnSubscribe, BackpressureStrategy)} to create a @@ -2196,6 +2318,7 @@ public static Flowable fromIterable(Iterable source) { * @see #create(FlowableOnSubscribe, BackpressureStrategy) */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") @@ -2203,7 +2326,7 @@ public static Flowable fromPublisher(final Publisher source) if (source instanceof Flowable) { return RxJavaPlugins.onAssembly((Flowable)source); } - ObjectHelper.requireNonNull(source, "publisher is null"); + ObjectHelper.requireNonNull(source, "source is null"); return RxJavaPlugins.onAssembly(new FlowableFromPublisher(source)); } @@ -2230,6 +2353,7 @@ public static Flowable fromPublisher(final Publisher source) * @return the new Flowable instance */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable generate(final Consumer> generator) { @@ -2263,6 +2387,7 @@ public static Flowable generate(final Consumer> generator) { * @return the new Flowable instance */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable generate(Callable initialState, final BiConsumer> generator) { @@ -2297,6 +2422,7 @@ public static Flowable generate(Callable initialState, final BiCons * @return the new Flowable instance */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable generate(Callable initialState, final BiConsumer> generator, @@ -2363,6 +2489,7 @@ public static Flowable generate(Callable initialState, BiFunction Flowable generate(Callable initialState, BiFunction, S> generator, Consumer disposeState) { @@ -2432,6 +2559,7 @@ public static Flowable interval(long initialDelay, long period, TimeUnit u * @since 1.0.12 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.CUSTOM) public static Flowable interval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) { @@ -2539,6 +2667,7 @@ public static Flowable intervalRange(long start, long count, long initialD * @return the new Flowable instance */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.CUSTOM) public static Flowable intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit, Scheduler scheduler) { @@ -2590,6 +2719,7 @@ public static Flowable intervalRange(long start, long count, long initialD * @see #fromIterable(Iterable) */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable just(T item) { @@ -2619,11 +2749,12 @@ public static Flowable just(T item) { */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable just(T item1, T item2) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); return fromArray(item1, item2); } @@ -2652,12 +2783,13 @@ public static Flowable just(T item1, T item2) { */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable just(T item1, T item2, T item3) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); - ObjectHelper.requireNonNull(item3, "The third item is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); + ObjectHelper.requireNonNull(item3, "item3 is null"); return fromArray(item1, item2, item3); } @@ -2688,13 +2820,14 @@ public static Flowable just(T item1, T item2, T item3) { */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable just(T item1, T item2, T item3, T item4) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); - ObjectHelper.requireNonNull(item3, "The third item is null"); - ObjectHelper.requireNonNull(item4, "The fourth item is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); + ObjectHelper.requireNonNull(item3, "item3 is null"); + ObjectHelper.requireNonNull(item4, "item4 is null"); return fromArray(item1, item2, item3, item4); } @@ -2727,14 +2860,15 @@ public static Flowable just(T item1, T item2, T item3, T item4) { */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable just(T item1, T item2, T item3, T item4, T item5) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); - ObjectHelper.requireNonNull(item3, "The third item is null"); - ObjectHelper.requireNonNull(item4, "The fourth item is null"); - ObjectHelper.requireNonNull(item5, "The fifth item is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); + ObjectHelper.requireNonNull(item3, "item3 is null"); + ObjectHelper.requireNonNull(item4, "item4 is null"); + ObjectHelper.requireNonNull(item5, "item5 is null"); return fromArray(item1, item2, item3, item4, item5); } @@ -2769,15 +2903,16 @@ public static Flowable just(T item1, T item2, T item3, T item4, T item5) */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable just(T item1, T item2, T item3, T item4, T item5, T item6) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); - ObjectHelper.requireNonNull(item3, "The third item is null"); - ObjectHelper.requireNonNull(item4, "The fourth item is null"); - ObjectHelper.requireNonNull(item5, "The fifth item is null"); - ObjectHelper.requireNonNull(item6, "The sixth item is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); + ObjectHelper.requireNonNull(item3, "item3 is null"); + ObjectHelper.requireNonNull(item4, "item4 is null"); + ObjectHelper.requireNonNull(item5, "item5 is null"); + ObjectHelper.requireNonNull(item6, "item6 is null"); return fromArray(item1, item2, item3, item4, item5, item6); } @@ -2814,16 +2949,17 @@ public static Flowable just(T item1, T item2, T item3, T item4, T item5, */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable just(T item1, T item2, T item3, T item4, T item5, T item6, T item7) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); - ObjectHelper.requireNonNull(item3, "The third item is null"); - ObjectHelper.requireNonNull(item4, "The fourth item is null"); - ObjectHelper.requireNonNull(item5, "The fifth item is null"); - ObjectHelper.requireNonNull(item6, "The sixth item is null"); - ObjectHelper.requireNonNull(item7, "The seventh item is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); + ObjectHelper.requireNonNull(item3, "item3 is null"); + ObjectHelper.requireNonNull(item4, "item4 is null"); + ObjectHelper.requireNonNull(item5, "item5 is null"); + ObjectHelper.requireNonNull(item6, "item6 is null"); + ObjectHelper.requireNonNull(item7, "item7 is null"); return fromArray(item1, item2, item3, item4, item5, item6, item7); } @@ -2862,17 +2998,18 @@ public static Flowable just(T item1, T item2, T item3, T item4, T item5, */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); - ObjectHelper.requireNonNull(item3, "The third item is null"); - ObjectHelper.requireNonNull(item4, "The fourth item is null"); - ObjectHelper.requireNonNull(item5, "The fifth item is null"); - ObjectHelper.requireNonNull(item6, "The sixth item is null"); - ObjectHelper.requireNonNull(item7, "The seventh item is null"); - ObjectHelper.requireNonNull(item8, "The eighth item is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); + ObjectHelper.requireNonNull(item3, "item3 is null"); + ObjectHelper.requireNonNull(item4, "item4 is null"); + ObjectHelper.requireNonNull(item5, "item5 is null"); + ObjectHelper.requireNonNull(item6, "item6 is null"); + ObjectHelper.requireNonNull(item7, "item7 is null"); + ObjectHelper.requireNonNull(item8, "item8 is null"); return fromArray(item1, item2, item3, item4, item5, item6, item7, item8); } @@ -2913,18 +3050,19 @@ public static Flowable just(T item1, T item2, T item3, T item4, T item5, */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); - ObjectHelper.requireNonNull(item3, "The third item is null"); - ObjectHelper.requireNonNull(item4, "The fourth item is null"); - ObjectHelper.requireNonNull(item5, "The fifth item is null"); - ObjectHelper.requireNonNull(item6, "The sixth item is null"); - ObjectHelper.requireNonNull(item7, "The seventh item is null"); - ObjectHelper.requireNonNull(item8, "The eighth item is null"); - ObjectHelper.requireNonNull(item9, "The ninth is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); + ObjectHelper.requireNonNull(item3, "item3 is null"); + ObjectHelper.requireNonNull(item4, "item4 is null"); + ObjectHelper.requireNonNull(item5, "item5 is null"); + ObjectHelper.requireNonNull(item6, "item6 is null"); + ObjectHelper.requireNonNull(item7, "item7 is null"); + ObjectHelper.requireNonNull(item8, "item8 is null"); + ObjectHelper.requireNonNull(item9, "item9 is null"); return fromArray(item1, item2, item3, item4, item5, item6, item7, item8, item9); } @@ -2967,19 +3105,20 @@ public static Flowable just(T item1, T item2, T item3, T item4, T item5, */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9, T item10) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); - ObjectHelper.requireNonNull(item3, "The third item is null"); - ObjectHelper.requireNonNull(item4, "The fourth item is null"); - ObjectHelper.requireNonNull(item5, "The fifth item is null"); - ObjectHelper.requireNonNull(item6, "The sixth item is null"); - ObjectHelper.requireNonNull(item7, "The seventh item is null"); - ObjectHelper.requireNonNull(item8, "The eighth item is null"); - ObjectHelper.requireNonNull(item9, "The ninth item is null"); - ObjectHelper.requireNonNull(item10, "The tenth item is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); + ObjectHelper.requireNonNull(item3, "item3 is null"); + ObjectHelper.requireNonNull(item4, "item4 is null"); + ObjectHelper.requireNonNull(item5, "item5 is null"); + ObjectHelper.requireNonNull(item6, "item6 is null"); + ObjectHelper.requireNonNull(item7, "item7 is null"); + ObjectHelper.requireNonNull(item8, "item8 is null"); + ObjectHelper.requireNonNull(item9, "item9 is null"); + ObjectHelper.requireNonNull(item10, "item10 is null"); return fromArray(item1, item2, item3, item4, item5, item6, item7, item8, item9, item10); } @@ -3357,6 +3496,7 @@ public static Flowable mergeArray(Publisher... sources) { */ @SuppressWarnings({ "unchecked", "rawtypes" }) @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable merge(Publisher source1, Publisher source2) { @@ -3406,6 +3546,7 @@ public static Flowable merge(Publisher source1, Publisher Flowable merge(Publisher source1, Publisher source2, Publisher source3) { @@ -3458,6 +3599,7 @@ public static Flowable merge(Publisher source1, Publisher Flowable merge( @@ -3767,6 +3909,7 @@ public static Flowable mergeArrayDelayError(Publisher... sou */ @SuppressWarnings({ "unchecked", "rawtypes" }) @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable mergeDelayError(Publisher source1, Publisher source2) { @@ -3809,6 +3952,7 @@ public static Flowable mergeDelayError(Publisher source1, Pu */ @SuppressWarnings({ "unchecked", "rawtypes" }) @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable mergeDelayError(Publisher source1, Publisher source2, Publisher source3) { @@ -3854,6 +3998,7 @@ public static Flowable mergeDelayError(Publisher source1, Pu */ @SuppressWarnings({ "unchecked", "rawtypes" }) @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable mergeDelayError( @@ -4069,6 +4214,7 @@ public static Single sequenceEqual(Publisher source1, * @see ReactiveX operators documentation: SequenceEqual */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Single sequenceEqual(Publisher source1, Publisher source2, @@ -4319,6 +4465,7 @@ public static Flowable timer(long delay, TimeUnit unit) { * @see ReactiveX operators documentation: Timer */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.CUSTOM) public static Flowable timer(long delay, TimeUnit unit, Scheduler scheduler) { @@ -4330,7 +4477,7 @@ public static Flowable timer(long delay, TimeUnit unit, Scheduler schedule /** * Create a Flowable by wrapping a Publisher which has to be implemented according - * to the Reactive-Streams specification by handling backpressure and + * to the Reactive Streams specification by handling backpressure and * cancellation correctly; no safeguards are provided by the Flowable itself. *

*
Backpressure:
@@ -4347,6 +4494,7 @@ public static Flowable timer(long delay, TimeUnit unit, Scheduler schedule * instead. */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.NONE) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable unsafeCreate(Publisher onSubscribe) { @@ -4420,6 +4568,7 @@ public static Flowable using(Callable resourceSupplier, * @since 2.0 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable using(Callable resourceSupplier, @@ -4427,7 +4576,7 @@ public static Flowable using(Callable resourceSupplier, Consumer resourceDisposer, boolean eager) { ObjectHelper.requireNonNull(resourceSupplier, "resourceSupplier is null"); ObjectHelper.requireNonNull(sourceSupplier, "sourceSupplier is null"); - ObjectHelper.requireNonNull(resourceDisposer, "disposer is null"); + ObjectHelper.requireNonNull(resourceDisposer, "resourceDisposer is null"); return RxJavaPlugins.onAssembly(new FlowableUsing(resourceSupplier, sourceSupplier, resourceDisposer, eager)); } @@ -4476,6 +4625,7 @@ public static Flowable using(Callable resourceSupplier, * @see ReactiveX operators documentation: Zip */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable zip(Iterable> sources, Function zipper) { @@ -4530,6 +4680,7 @@ public static Flowable zip(Iterable> */ @SuppressWarnings({ "rawtypes", "unchecked", "cast" }) @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable zip(Publisher> sources, @@ -4588,6 +4739,7 @@ public static Flowable zip(Publisher> */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable zip( @@ -4649,6 +4801,7 @@ public static Flowable zip( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable zip( @@ -4711,6 +4864,7 @@ public static Flowable zip( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable zip( @@ -4775,6 +4929,7 @@ public static Flowable zip( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable zip( @@ -4843,6 +4998,7 @@ public static Flowable zip( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable zip( @@ -4916,6 +5072,7 @@ public static Flowable zip( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable zip( @@ -4992,6 +5149,7 @@ public static Flowable zip( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable zip( @@ -5072,6 +5230,7 @@ public static Flowable zip( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable zip( @@ -5157,6 +5316,7 @@ public static Flowable zip( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable zip( @@ -5246,6 +5406,7 @@ public static Flowable zip( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable zip( @@ -5316,6 +5477,7 @@ public static Flowable zip( * @see ReactiveX operators documentation: Zip */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable zipArray(Function zipper, @@ -5378,6 +5540,7 @@ public static Flowable zipArray(FunctionReactiveX operators documentation: Zip */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public static Flowable zipIterable(Iterable> sources, @@ -5413,6 +5576,7 @@ public static Flowable zipIterable(IterableReactiveX operators documentation: All */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Single all(Predicate predicate) { @@ -5442,6 +5606,7 @@ public final Single all(Predicate predicate) { */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable ambWith(Publisher other) { @@ -5473,6 +5638,7 @@ public final Flowable ambWith(Publisher other) { * @see ReactiveX operators documentation: Contains */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Single any(Predicate predicate) { @@ -6203,6 +6369,7 @@ public final Flowable> buffer(int count, int skip) { * @see ReactiveX operators documentation: Buffer */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final > Flowable buffer(int count, int skip, Callable bufferSupplier) { @@ -6352,6 +6519,7 @@ public final Flowable> buffer(long timespan, long timeskip, TimeUnit uni * @see ReactiveX operators documentation: Buffer */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.CUSTOM) public final > Flowable buffer(long timespan, long timeskip, TimeUnit unit, @@ -6965,6 +7133,7 @@ public final Flowable cacheWithInitialCapacity(int initialCapacity) { * @see ReactiveX operators documentation: Map */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable cast(final Class clazz) { @@ -7002,6 +7171,7 @@ public final Flowable cast(final Class clazz) { * @see ReactiveX operators documentation: Reduce */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Single collect(Callable initialItemSupplier, BiConsumer collector) { @@ -7040,6 +7210,7 @@ public final Single collect(Callable initialItemSupplier, Bi * @see ReactiveX operators documentation: Reduce */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Single collectInto(final U initialItem, BiConsumer collector) { @@ -7137,6 +7308,7 @@ public final Flowable concatMap(FunctionReactiveX operators documentation: FlatMap */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable concatMap(Function> mapper, int prefetch) { @@ -7205,6 +7377,7 @@ public final Completable concatMapCompletable(Function mapper, int prefetch) { @@ -7307,6 +7480,7 @@ public final Completable concatMapCompletableDelayError(Function mapper, boolean tillTheEnd, int prefetch) { @@ -7370,6 +7544,7 @@ public final Flowable concatMapDelayError(Function Flowable concatMapDelayError(Function> mapper, @@ -7437,6 +7612,7 @@ public final Flowable concatMapEager(Function Flowable concatMapEager(Function> mapper, @@ -7506,6 +7682,7 @@ public final Flowable concatMapEagerDelayError(Function Flowable concatMapEagerDelayError(Function> mapper, @@ -7570,6 +7747,7 @@ public final Flowable concatMapIterable(FunctionReactiveX operators documentation: FlatMap */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable concatMapIterable(final Function> mapper, int prefetch) { @@ -7638,6 +7816,7 @@ public final Flowable concatMapMaybe(Function Flowable concatMapMaybe(Function> mapper, int prefetch) { @@ -7748,6 +7927,7 @@ public final Flowable concatMapMaybeDelayError(Function Flowable concatMapMaybeDelayError(Function> mapper, boolean tillTheEnd, int prefetch) { @@ -7816,6 +7996,7 @@ public final Flowable concatMapSingle(Function Flowable concatMapSingle(Function> mapper, int prefetch) { @@ -7926,6 +8107,7 @@ public final Flowable concatMapSingleDelayError(Function Flowable concatMapSingleDelayError(Function> mapper, boolean tillTheEnd, int prefetch) { @@ -7955,6 +8137,7 @@ public final Flowable concatMapSingleDelayError(FunctionReactiveX operators documentation: Concat */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable concatWith(Publisher other) { @@ -8059,6 +8242,7 @@ public final Flowable concatWith(@NonNull CompletableSource other) { * @see ReactiveX operators documentation: Contains */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Single contains(final Object item) { @@ -8082,7 +8266,6 @@ public final Single contains(final Object item) { * @return a Single that emits a single item: the number of items emitted by the source Publisher as a * 64-bit Long item * @see ReactiveX operators documentation: Count - * @see #count() */ @CheckReturnValue @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @@ -8096,6 +8279,14 @@ public final Single count() { * source Publisher that are followed by another item within a computed debounce duration. *

* + *

+ * The delivery of the item happens on the thread of the first {@code onNext} or {@code onComplete} + * signal of the generated {@code Publisher} sequence, + * which if takes too long, a newer item may arrive from the upstream, causing the + * generated sequence to get cancelled, which may also interrupt any downstream blocking operation + * (yielding an {@code InterruptedException}). It is recommended processing items + * that may take long time to be moved to another thread via {@link #observeOn} applied after + * {@code debounce} itself. *

*
Backpressure:
*
This operator does not support backpressure as it uses the {@code debounceSelector} to mark @@ -8114,6 +8305,7 @@ public final Single count() { * @see RxJava wiki: Backpressure */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable debounce(Function> debounceIndicator) { @@ -8130,6 +8322,13 @@ public final Flowable debounce(Function * will be emitted by the resulting Publisher. *

* + *

+ * Delivery of the item after the grace period happens on the {@code computation} {@code Scheduler}'s + * {@code Worker} which if takes too long, a newer item may arrive from the upstream, causing the + * {@code Worker}'s task to get disposed, which may also interrupt any downstream blocking operation + * (yielding an {@code InterruptedException}). It is recommended processing items + * that may take long time to be moved to another thread via {@link #observeOn} applied after + * {@code debounce} itself. *

*
Backpressure:
*
This operator does not support backpressure as it uses time to control data flow.
@@ -8165,6 +8364,13 @@ public final Flowable debounce(long timeout, TimeUnit unit) { * will be emitted by the resulting Publisher. *

* + *

+ * Delivery of the item after the grace period happens on the given {@code Scheduler}'s + * {@code Worker} which if takes too long, a newer item may arrive from the upstream, causing the + * {@code Worker}'s task to get disposed, which may also interrupt any downstream blocking operation + * (yielding an {@code InterruptedException}). It is recommended processing items + * that may take long time to be moved to another thread via {@link #observeOn} applied after + * {@code debounce} itself. *

*
Backpressure:
*
This operator does not support backpressure as it uses time to control data flow.
@@ -8187,6 +8393,7 @@ public final Flowable debounce(long timeout, TimeUnit unit) { * @see #throttleWithTimeout(long, TimeUnit, Scheduler) */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable debounce(long timeout, TimeUnit unit, Scheduler scheduler) { @@ -8217,10 +8424,11 @@ public final Flowable debounce(long timeout, TimeUnit unit, Scheduler schedul * @see ReactiveX operators documentation: DefaultIfEmpty */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable defaultIfEmpty(T defaultItem) { - ObjectHelper.requireNonNull(defaultItem, "item is null"); + ObjectHelper.requireNonNull(defaultItem, "defaultItem is null"); return switchIfEmpty(just(defaultItem)); } @@ -8252,6 +8460,7 @@ public final Flowable defaultIfEmpty(T defaultItem) { * @see ReactiveX operators documentation: Delay */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable delay(final Function> itemDelayIndicator) { @@ -8367,6 +8576,7 @@ public final Flowable delay(long delay, TimeUnit unit, Scheduler scheduler) { * @see ReactiveX operators documentation: Delay */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable delay(long delay, TimeUnit unit, Scheduler scheduler, boolean delayError) { @@ -8435,6 +8645,7 @@ public final Flowable delay(Publisher subscriptionIndicator, * @since 2.0 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable delaySubscription(Publisher subscriptionIndicator) { @@ -8598,6 +8809,7 @@ public final Flowable dematerialize() { */ @Experimental @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) @BackpressureSupport(BackpressureKind.PASS_THROUGH) public final Flowable dematerialize(Function> selector) { @@ -8746,7 +8958,7 @@ public final Flowable distinct(Function keySelector, * {@code CharSequence}s or {@code List}s where the objects will actually have the same * references when they are modified and {@code distinctUntilChanged} will evaluate subsequent items as same. * To avoid such situation, it is recommended that mutable data is converted to an immutable one, - * for example using `map(CharSequence::toString)` or `map(list -> Collections.unmodifiableList(new ArrayList<>(list)))`. + * for example using {@code map(CharSequence::toString)} or {@code map(list -> Collections.unmodifiableList(new ArrayList<>(list)))}. *
*
Backpressure:
*
The operator doesn't interfere with backpressure which is determined by the source {@code Publisher}'s @@ -8789,7 +9001,7 @@ public final Flowable distinctUntilChanged() { * {@code CharSequence}s or {@code List}s where the objects will actually have the same * references when they are modified and {@code distinctUntilChanged} will evaluate subsequent items as same. * To avoid such situation, it is recommended that mutable data is converted to an immutable one, - * for example using `map(CharSequence::toString)` or `map(list -> Collections.unmodifiableList(new ArrayList<>(list)))`. + * for example using {@code map(CharSequence::toString)} or {@code map(list -> Collections.unmodifiableList(new ArrayList<>(list)))}. *
*
Backpressure:
*
The operator doesn't interfere with backpressure which is determined by the source {@code Publisher}'s @@ -8828,7 +9040,7 @@ public final Flowable distinctUntilChanged(Function keySele * {@code CharSequence}s or {@code List}s where the objects will actually have the same * references when they are modified and {@code distinctUntilChanged} will evaluate subsequent items as same. * To avoid such situation, it is recommended that mutable data is converted to an immutable one, - * for example using `map(CharSequence::toString)` or `map(list -> Collections.unmodifiableList(new ArrayList<>(list)))`. + * for example using {@code map(CharSequence::toString)} or {@code map(list -> Collections.unmodifiableList(new ArrayList<>(list)))}. *
*
Backpressure:
*
The operator doesn't interfere with backpressure which is determined by the source {@code Publisher}'s @@ -9011,6 +9223,7 @@ public final Flowable doOnComplete(Action onComplete) { * @see ReactiveX operators documentation: Do */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) private Flowable doOnEach(Consumer onNext, Consumer onError, @@ -9040,10 +9253,11 @@ private Flowable doOnEach(Consumer onNext, ConsumerReactiveX operators documentation: Do */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable doOnEach(final Consumer> onNotification) { - ObjectHelper.requireNonNull(onNotification, "consumer is null"); + ObjectHelper.requireNonNull(onNotification, "onNotification is null"); return doOnEach( Functions.notificationOnNext(onNotification), Functions.notificationOnError(onNotification), @@ -9076,6 +9290,7 @@ public final Flowable doOnEach(final Consumer> onNoti * @see ReactiveX operators documentation: Do */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable doOnEach(final Subscriber subscriber) { @@ -9138,6 +9353,7 @@ public final Flowable doOnError(Consumer onError) { * @see ReactiveX operators documentation: Do */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable doOnLifecycle(final Consumer onSubscribe, @@ -9289,7 +9505,7 @@ public final Maybe elementAt(long index) { } /** - * Returns a Flowable that emits the item found at a specified index in a sequence of emissions from + * Returns a Single that emits the item found at a specified index in a sequence of emissions from * this Flowable, or a default item if that index is out of range. *

* @@ -9305,13 +9521,14 @@ public final Maybe elementAt(long index) { * the zero-based index of the item to retrieve * @param defaultItem * the default item - * @return a Flowable that emits the item at the specified position in the sequence emitted by the source + * @return a Single that emits the item at the specified position in the sequence emitted by the source * Publisher, or the default item if that index is outside the bounds of the source sequence * @throws IndexOutOfBoundsException * if {@code index} is less than 0 * @see ReactiveX operators documentation: ElementAt */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Single elementAt(long index, T defaultItem) { @@ -9323,7 +9540,7 @@ public final Single elementAt(long index, T defaultItem) { } /** - * Returns a Flowable that emits the item found at a specified index in a sequence of emissions from + * Returns a Single that emits the item found at a specified index in a sequence of emissions from * this Flowable or signals a {@link NoSuchElementException} if this Flowable has fewer elements than index. *

* @@ -9337,7 +9554,7 @@ public final Single elementAt(long index, T defaultItem) { * * @param index * the zero-based index of the item to retrieve - * @return a Flowable that emits the item at the specified position in the sequence emitted by the source + * @return a Single that emits the item at the specified position in the sequence emitted by the source * Publisher, or the default item if that index is outside the bounds of the source sequence * @throws IndexOutOfBoundsException * if {@code index} is less than 0 @@ -9373,6 +9590,7 @@ public final Single elementAtOrError(long index) { * @see ReactiveX operators documentation: Filter */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable filter(Predicate predicate) { @@ -9629,6 +9847,7 @@ public final Flowable flatMap(Function Flowable flatMap(Function> mapper, @@ -9677,6 +9896,7 @@ public final Flowable flatMap(FunctionReactiveX operators documentation: FlatMap */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable flatMap( @@ -9723,6 +9943,7 @@ public final Flowable flatMap( * @since 2.0 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable flatMap( @@ -9893,6 +10114,7 @@ public final Flowable flatMap(Function Flowable flatMap(final Function> mapper, @@ -9981,6 +10203,7 @@ public final Completable flatMapCompletable(Function mapper, boolean delayErrors, int maxConcurrency) { @@ -10045,6 +10268,7 @@ public final Flowable flatMapIterable(final FunctionReactiveX operators documentation: FlatMap */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable flatMapIterable(final Function> mapper, int bufferSize) { @@ -10081,6 +10305,7 @@ public final Flowable flatMapIterable(final FunctionReactiveX operators documentation: FlatMap */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable flatMapIterable(final Function> mapper, @@ -10123,6 +10348,7 @@ public final Flowable flatMapIterable(final Function Flowable flatMapIterable(final Function> mapper, @@ -10172,6 +10398,7 @@ public final Flowable flatMapMaybe(Function Flowable flatMapMaybe(Function> mapper, boolean delayErrors, int maxConcurrency) { @@ -10220,6 +10447,7 @@ public final Flowable flatMapSingle(Function Flowable flatMapSingle(Function> mapper, boolean delayErrors, int maxConcurrency) { @@ -10340,6 +10568,7 @@ public final Disposable forEachWhile(Predicate onNext, ConsumerReactiveX operators documentation: Subscribe */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.NONE) @SchedulerSupport(SchedulerSupport.NONE) public final Disposable forEachWhile(final Predicate onNext, final Consumer onError, @@ -10611,6 +10840,7 @@ public final Flowable> groupBy(FunctionReactiveX operators documentation: GroupBy */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable> groupBy(Function keySelector, @@ -10723,6 +10953,7 @@ public final Flowable> groupBy(Function Flowable> groupBy(Function keySelector, @@ -10772,6 +11003,7 @@ public final Flowable> groupBy(FunctionReactiveX operators documentation: Join */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable groupJoin( @@ -10893,6 +11125,7 @@ public final Single isEmpty() { * @see ReactiveX operators documentation: Join */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable join( @@ -10950,6 +11183,7 @@ public final Maybe lastElement() { * @see ReactiveX operators documentation: Last */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Single last(T defaultItem) { @@ -11127,6 +11361,7 @@ public final Single lastOrError() { * @see #compose(FlowableTransformer) */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.SPECIAL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable lift(FlowableOperator lifter) { @@ -11201,6 +11436,7 @@ public final Flowable limit(long count) { * @see ReactiveX operators documentation: Map */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable map(Function mapper) { @@ -11254,6 +11490,7 @@ public final Flowable> materialize() { * @see ReactiveX operators documentation: Merge */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable mergeWith(Publisher other) { @@ -11281,6 +11518,7 @@ public final Flowable mergeWith(Publisher other) { * @since 2.2 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable mergeWith(@NonNull SingleSource other) { @@ -11309,6 +11547,7 @@ public final Flowable mergeWith(@NonNull SingleSource other) { * @since 2.2 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable mergeWith(@NonNull MaybeSource other) { @@ -11334,6 +11573,7 @@ public final Flowable mergeWith(@NonNull MaybeSource other) { * @since 2.2 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable mergeWith(@NonNull CompletableSource other) { @@ -11349,6 +11589,11 @@ public final Flowable mergeWith(@NonNull CompletableSource other) { * asynchronous. If strict event ordering is required, consider using the {@link #observeOn(Scheduler, boolean)} overload. *

* + *

+ * This operator keeps emitting as many signals as it can on the given Scheduler's Worker thread, + * which may result in a longer than expected occupation of this thread. In other terms, + * it does not allow per-signal fairness in case the worker runs on a shared underlying thread. + * If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead. *

*
Backpressure:
*
This operator honors backpressure from downstream and expects it from the source {@code Publisher}. Violating this @@ -11369,6 +11614,7 @@ public final Flowable mergeWith(@NonNull CompletableSource other) { * @see #subscribeOn * @see #observeOn(Scheduler, boolean) * @see #observeOn(Scheduler, boolean, int) + * @see #delay(long, TimeUnit, Scheduler) */ @CheckReturnValue @BackpressureSupport(BackpressureKind.FULL) @@ -11382,6 +11628,11 @@ public final Flowable observeOn(Scheduler scheduler) { * asynchronously with a bounded buffer and optionally delays onError notifications. *

* + *

+ * This operator keeps emitting as many signals as it can on the given Scheduler's Worker thread, + * which may result in a longer than expected occupation of this thread. In other terms, + * it does not allow per-signal fairness in case the worker runs on a shared underlying thread. + * If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead. *

*
Backpressure:
*
This operator honors backpressure from downstream and expects it from the source {@code Publisher}. Violating this @@ -11406,6 +11657,7 @@ public final Flowable observeOn(Scheduler scheduler) { * @see #subscribeOn * @see #observeOn(Scheduler) * @see #observeOn(Scheduler, boolean, int) + * @see #delay(long, TimeUnit, Scheduler, boolean) */ @CheckReturnValue @BackpressureSupport(BackpressureKind.FULL) @@ -11419,6 +11671,11 @@ public final Flowable observeOn(Scheduler scheduler, boolean delayError) { * asynchronously with a bounded buffer of configurable size and optionally delays onError notifications. *

* + *

+ * This operator keeps emitting as many signals as it can on the given Scheduler's Worker thread, + * which may result in a longer than expected occupation of this thread. In other terms, + * it does not allow per-signal fairness in case the worker runs on a shared underlying thread. + * If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead. *

*
Backpressure:
*
This operator honors backpressure from downstream and expects it from the source {@code Publisher}. Violating this @@ -11444,8 +11701,10 @@ public final Flowable observeOn(Scheduler scheduler, boolean delayError) { * @see #subscribeOn * @see #observeOn(Scheduler) * @see #observeOn(Scheduler, boolean) + * @see #delay(long, TimeUnit, Scheduler, boolean) */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) { @@ -11473,6 +11732,7 @@ public final Flowable observeOn(Scheduler scheduler, boolean delayError, int * @see ReactiveX operators documentation: Filter */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable ofType(final Class clazz) { @@ -11617,7 +11877,7 @@ public final Flowable onBackpressureBuffer(int capacity, boolean delayError) @BackpressureSupport(BackpressureKind.SPECIAL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable onBackpressureBuffer(int capacity, boolean delayError, boolean unbounded) { - ObjectHelper.verifyPositive(capacity, "bufferSize"); + ObjectHelper.verifyPositive(capacity, "capacity"); return RxJavaPlugins.onAssembly(new FlowableOnBackpressureBuffer(this, capacity, unbounded, delayError, Functions.EMPTY_ACTION)); } @@ -11649,6 +11909,7 @@ public final Flowable onBackpressureBuffer(int capacity, boolean delayError, * @since 1.1.0 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.SPECIAL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable onBackpressureBuffer(int capacity, boolean delayError, boolean unbounded, @@ -11720,10 +11981,11 @@ public final Flowable onBackpressureBuffer(int capacity, Action onOverflow) { * @since 2.0 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.SPECIAL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable onBackpressureBuffer(long capacity, Action onOverflow, BackpressureOverflowStrategy overflowStrategy) { - ObjectHelper.requireNonNull(overflowStrategy, "strategy is null"); + ObjectHelper.requireNonNull(overflowStrategy, "overflowStrategy is null"); ObjectHelper.verifyPositive(capacity, "capacity"); return RxJavaPlugins.onAssembly(new FlowableOnBackpressureBufferStrategy(this, capacity, onOverflow, overflowStrategy)); } @@ -11776,6 +12038,7 @@ public final Flowable onBackpressureDrop() { * @since 1.1.0 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable onBackpressureDrop(Consumer onDrop) { @@ -11851,6 +12114,7 @@ public final Flowable onBackpressureLatest() { * @see ReactiveX operators documentation: Catch */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable onErrorResumeNext(Function> resumeFunction) { @@ -11894,6 +12158,7 @@ public final Flowable onErrorResumeNext(FunctionReactiveX operators documentation: Catch */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable onErrorResumeNext(final Publisher next) { @@ -11933,6 +12198,7 @@ public final Flowable onErrorResumeNext(final Publisher next) { * @see ReactiveX operators documentation: Catch */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable onErrorReturn(Function valueSupplier) { @@ -11972,6 +12238,7 @@ public final Flowable onErrorReturn(Function * @see ReactiveX operators documentation: Catch */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable onErrorReturnItem(final T item) { @@ -12018,6 +12285,7 @@ public final Flowable onErrorReturnItem(final T item) { * @see ReactiveX operators documentation: Catch */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable onExceptionResumeNext(final Publisher next) { @@ -12226,6 +12494,7 @@ public final Flowable publish(Function, ? extends Pub * @see ReactiveX operators documentation: Publish */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable publish(Function, ? extends Publisher> selector, int prefetch) { @@ -12320,6 +12589,7 @@ public final Flowable rebatchRequests(int n) { * @see Wikipedia: Fold (higher-order function) */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Maybe reduce(BiFunction reducer) { @@ -12381,6 +12651,7 @@ public final Maybe reduce(BiFunction reducer) { * @see #reduceWith(Callable, BiFunction) */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Single reduce(R seed, BiFunction reducer) { @@ -12425,6 +12696,7 @@ public final Single reduce(R seed, BiFunction reducer) { * @see Wikipedia: Fold (higher-order function) */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Single reduceWith(Callable seedSupplier, BiFunction reducer) { @@ -12512,6 +12784,7 @@ public final Flowable repeat(long times) { * @see ReactiveX operators documentation: Repeat */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable repeatUntil(BooleanSupplier stop) { @@ -12542,6 +12815,7 @@ public final Flowable repeatUntil(BooleanSupplier stop) { * @see ReactiveX operators documentation: Repeat */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable repeatWhen(final Function, ? extends Publisher> handler) { @@ -12600,6 +12874,7 @@ public final ConnectableFlowable replay() { * @see ReactiveX operators documentation: Replay */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable replay(Function, ? extends Publisher> selector) { @@ -12638,6 +12913,7 @@ public final Flowable replay(Function, ? extends Publ * @see ReactiveX operators documentation: Replay */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable replay(Function, ? extends Publisher> selector, final int bufferSize) { @@ -12728,6 +13004,7 @@ public final Flowable replay(Function, ? extends Publ * @see ReactiveX operators documentation: Replay */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable replay(Function, ? extends Publisher> selector, final int bufferSize, final long time, final TimeUnit unit, final Scheduler scheduler) { @@ -12772,6 +13049,7 @@ public final Flowable replay(Function, ? extends Publ * @see ReactiveX operators documentation: Replay */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable replay(final Function, ? extends Publisher> selector, final int bufferSize, final Scheduler scheduler) { @@ -12851,6 +13129,7 @@ public final Flowable replay(Function, ? extends Publ * @see ReactiveX operators documentation: Replay */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable replay(Function, ? extends Publisher> selector, final long time, final TimeUnit unit, final Scheduler scheduler) { @@ -12887,6 +13166,7 @@ public final Flowable replay(Function, ? extends Publ * @see ReactiveX operators documentation: Replay */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable replay(final Function, ? extends Publisher> selector, final Scheduler scheduler) { @@ -13195,6 +13475,7 @@ public final Flowable retry() { * @see ReactiveX operators documentation: Retry */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable retry(BiPredicate predicate) { @@ -13226,7 +13507,7 @@ public final Flowable retry(BiPredicate p *
* * @param count - * number of retry attempts before failing + * the number of times to resubscribe if the current Flowable fails * @return the source Publisher modified with retry logic * @see ReactiveX operators documentation: Retry */ @@ -13247,11 +13528,12 @@ public final Flowable retry(long count) { *
Scheduler:
*
{@code retry} does not operate by default on a particular {@link Scheduler}.
*
- * @param times the number of times to repeat + * @param times the number of times to resubscribe if the current Flowable fails * @param predicate the predicate called with the failure Throwable and should return true to trigger a retry. * @return the new Flowable instance */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable retry(long times, Predicate predicate) { @@ -13296,6 +13578,7 @@ public final Flowable retry(Predicate predicate) { * @return the new Flowable instance */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable retryUntil(final BooleanSupplier stop) { @@ -13381,6 +13664,7 @@ public final Flowable retryUntil(final BooleanSupplier stop) { * @see ReactiveX operators documentation: Retry */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable retryWhen( @@ -13394,7 +13678,7 @@ public final Flowable retryWhen( * Subscribes to the current Flowable and wraps the given Subscriber into a SafeSubscriber * (if not already a SafeSubscriber) that * deals with exceptions thrown by a misbehaving Subscriber (that doesn't follow the - * Reactive-Streams specification). + * Reactive Streams specification). *
*
Backpressure:
*
This operator leaves the reactive world and the backpressure behavior depends on the Subscriber's behavior.
@@ -13504,6 +13788,7 @@ public final Flowable sample(long period, TimeUnit unit, boolean emitLast) { * @see #throttleLast(long, TimeUnit, Scheduler) */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable sample(long period, TimeUnit unit, Scheduler scheduler) { @@ -13544,6 +13829,7 @@ public final Flowable sample(long period, TimeUnit unit, Scheduler scheduler) * @since 2.1 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable sample(long period, TimeUnit unit, Scheduler scheduler, boolean emitLast) { @@ -13575,6 +13861,7 @@ public final Flowable sample(long period, TimeUnit unit, Scheduler scheduler, * @see RxJava wiki: Backpressure */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable sample(Publisher sampler) { @@ -13612,6 +13899,7 @@ public final Flowable sample(Publisher sampler) { * @since 2.1 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable sample(Publisher sampler, boolean emitLast) { @@ -13644,6 +13932,7 @@ public final Flowable sample(Publisher sampler, boolean emitLast) { * @see ReactiveX operators documentation: Scan */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable scan(BiFunction accumulator) { @@ -13697,10 +13986,11 @@ public final Flowable scan(BiFunction accumulator) { * @see ReactiveX operators documentation: Scan */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable scan(final R initialValue, BiFunction accumulator) { - ObjectHelper.requireNonNull(initialValue, "seed is null"); + ObjectHelper.requireNonNull(initialValue, "initialValue is null"); return scanWith(Functions.justCallable(initialValue), accumulator); } @@ -13736,6 +14026,7 @@ public final Flowable scan(final R initialValue, BiFunctionReactiveX operators documentation: Scan */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable scanWith(Callable seedSupplier, BiFunction accumulator) { @@ -13847,6 +14138,7 @@ public final Maybe singleElement() { * @see ReactiveX operators documentation: First */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Single single(T defaultItem) { @@ -14168,6 +14460,7 @@ public final Flowable skipLast(long time, TimeUnit unit, Scheduler scheduler, * @see ReactiveX operators documentation: SkipLast */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable skipLast(long time, TimeUnit unit, Scheduler scheduler, boolean delayError, int bufferSize) { @@ -14201,6 +14494,7 @@ public final Flowable skipLast(long time, TimeUnit unit, Scheduler scheduler, * @see ReactiveX operators documentation: SkipUntil */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable skipUntil(Publisher other) { @@ -14228,6 +14522,7 @@ public final Flowable skipUntil(Publisher other) { * @see ReactiveX operators documentation: SkipWhile */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable skipWhile(Predicate predicate) { @@ -14283,6 +14578,7 @@ public final Flowable sorted() { * @return a Flowable that emits the items emitted by the source Publisher in sorted order */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable sorted(Comparator sortFunction) { @@ -14340,6 +14636,7 @@ public final Flowable startWith(Iterable items) { */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable startWith(Publisher other) { @@ -14369,10 +14666,11 @@ public final Flowable startWith(Publisher other) { */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable startWith(T value) { - ObjectHelper.requireNonNull(value, "item is null"); + ObjectHelper.requireNonNull(value, "value is null"); return concatArray(just(value), this); } @@ -14559,6 +14857,7 @@ public final Disposable subscribe(Consumer onNext, ConsumerReactiveX operators documentation: Subscribe */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.SPECIAL) @SchedulerSupport(SchedulerSupport.NONE) public final Disposable subscribe(Consumer onNext, Consumer onError, @@ -14602,7 +14901,7 @@ public final void subscribe(Subscriber s) { * If the {@link Flowable} rejects the subscription attempt or otherwise fails it will signal * the error via {@link FlowableSubscriber#onError(Throwable)}. *

- * This subscribe method relaxes the following Reactive-Streams rules: + * This subscribe method relaxes the following Reactive Streams rules: *

    *
  • §1.3: onNext should not be called concurrently until onSubscribe returns. * FlowableSubscriber.onSubscribe should make sure a sync or async call triggered by request() is safe.
    • @@ -14719,6 +15018,7 @@ public final > E subscribeWith(E subscriber) { * @see #subscribeOn(Scheduler, boolean) */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable subscribeOn(@NonNull Scheduler scheduler) { @@ -14756,6 +15056,7 @@ public final Flowable subscribeOn(@NonNull Scheduler scheduler) { * @since 2.2 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable subscribeOn(@NonNull Scheduler scheduler, boolean requestOn) { @@ -14786,6 +15087,7 @@ public final Flowable subscribeOn(@NonNull Scheduler scheduler, boolean reque * @since 1.1.0 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable switchIfEmpty(Publisher other) { @@ -14818,6 +15120,7 @@ public final Flowable switchIfEmpty(Publisher other) { * Publisher * @return a Flowable that emits the items emitted by the Publisher returned from applying {@code func} to the most recently emitted item emitted by the source Publisher * @see ReactiveX operators documentation: FlatMap + * @see #switchMapDelayError(Function) */ @CheckReturnValue @BackpressureSupport(BackpressureKind.FULL) @@ -14853,6 +15156,7 @@ public final Flowable switchMap(FunctionReactiveX operators documentation: FlatMap + * @see #switchMapDelayError(Function, int) */ @CheckReturnValue @BackpressureSupport(BackpressureKind.FULL) @@ -14899,6 +15203,7 @@ public final Flowable switchMap(Function mapper) { @@ -14941,10 +15246,11 @@ public final Completable switchMapCompletable(@NonNull Function mapper) { @@ -14978,6 +15284,7 @@ public final Completable switchMapCompletableDelayError(@NonNull FunctionReactiveX operators documentation: FlatMap + * @see #switchMap(Function) * @since 2.0 */ @CheckReturnValue @@ -15015,6 +15322,7 @@ public final Flowable switchMapDelayError(FunctionReactiveX operators documentation: FlatMap + * @see #switchMap(Function, int) * @since 2.0 */ @CheckReturnValue @@ -15068,9 +15376,11 @@ Flowable switchMap0(Function> * and get subscribed to. * @return the new Flowable instance * @see #switchMapMaybe(Function) + * @see #switchMapMaybeDelayError(Function) * @since 2.2 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable switchMapMaybe(@NonNull Function> mapper) { @@ -15101,6 +15411,7 @@ public final Flowable switchMapMaybe(@NonNull Function Flowable switchMapMaybeDelayError(@NonNull Function> mapper) { @@ -15137,10 +15448,11 @@ public final Flowable switchMapMaybeDelayError(@NonNull Function Flowable switchMapSingle(@NonNull Function> mapper) { @@ -15171,6 +15483,7 @@ public final Flowable switchMapSingle(@NonNull Function Flowable switchMapSingleDelayError(@NonNull Function> mapper) { @@ -15414,6 +15727,7 @@ public final Flowable takeLast(long count, long time, TimeUnit unit, Schedule * @see ReactiveX operators documentation: TakeLast */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable takeLast(long count, long time, TimeUnit unit, Scheduler scheduler, boolean delayError, int bufferSize) { @@ -15625,6 +15939,7 @@ public final Flowable takeLast(long time, TimeUnit unit, Scheduler scheduler, * @since 1.1.0 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable takeUntil(Predicate stopPredicate) { @@ -15654,6 +15969,7 @@ public final Flowable takeUntil(Predicate stopPredicate) { * @see ReactiveX operators documentation: TakeUntil */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable takeUntil(Publisher other) { @@ -15682,6 +15998,7 @@ public final Flowable takeUntil(Publisher other) { * @see Flowable#takeUntil(Predicate) */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable takeWhile(Predicate predicate) { @@ -15746,6 +16063,7 @@ public final Flowable throttleFirst(long windowDuration, TimeUnit unit) { * @see RxJava wiki: Backpressure */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable throttleFirst(long skipDuration, TimeUnit unit, Scheduler scheduler) { @@ -15965,6 +16283,7 @@ public final Flowable throttleLatest(long timeout, TimeUnit unit, Scheduler s * @since 2.2 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable throttleLatest(long timeout, TimeUnit unit, Scheduler scheduler, boolean emitLast) { @@ -16218,6 +16537,7 @@ public final Flowable timeout(Function> * @see ReactiveX operators documentation: Timeout */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable timeout(Function> itemTimeoutIndicator, Flowable other) { @@ -16257,7 +16577,7 @@ public final Flowable timeout(long timeout, TimeUnit timeUnit) { /** * Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted * item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, - * the resulting Publisher begins instead to mirror a fallback Publisher. + * the source Publisher is disposed and resulting Publisher begins instead to mirror a fallback Publisher. *

    * *

    @@ -16280,6 +16600,7 @@ public final Flowable timeout(long timeout, TimeUnit timeUnit) { * @see ReactiveX operators documentation: Timeout */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.COMPUTATION) public final Flowable timeout(long timeout, TimeUnit timeUnit, Publisher other) { @@ -16290,7 +16611,8 @@ public final Flowable timeout(long timeout, TimeUnit timeUnit, Publisher * *
    @@ -16316,6 +16638,7 @@ public final Flowable timeout(long timeout, TimeUnit timeUnit, PublisherReactiveX operators documentation: Timeout */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler, Publisher other) { @@ -16387,6 +16710,7 @@ public final Flowable timeout(long timeout, TimeUnit timeUnit, Scheduler sche * @see ReactiveX operators documentation: Timeout */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable timeout(Publisher firstTimeoutIndicator, @@ -16432,6 +16756,7 @@ public final Flowable timeout(Publisher firstTimeoutIndicator, * @see ReactiveX operators documentation: Timeout */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable timeout( @@ -16556,6 +16881,7 @@ public final Flowable> timestamp(TimeUnit unit) { * @see ReactiveX operators documentation: Timestamp */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) // Supplied scheduler is only used for creating timestamps. public final Flowable> timestamp(final TimeUnit unit, final Scheduler scheduler) { @@ -16726,6 +17052,7 @@ public final > Single toList(Callable coll * @see ReactiveX operators documentation: To */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Single> toMap(final Function keySelector) { @@ -16764,6 +17091,7 @@ public final Single> toMap(final Function * @see ReactiveX operators documentation: To */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Single> toMap(final Function keySelector, final Function valueSelector) { @@ -16802,6 +17130,7 @@ public final Single> toMap(final FunctionReactiveX operators documentation: To */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Single> toMap(final Function keySelector, @@ -16915,6 +17244,7 @@ public final Single>> toMultimap(FunctionReactiveX operators documentation: To */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Single>> toMultimap( @@ -17046,6 +17376,7 @@ public final Single> toSortedList() { * @see ReactiveX operators documentation: To */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Single> toSortedList(final Comparator comparator) { @@ -17081,6 +17412,7 @@ public final Single> toSortedList(final Comparator comparator * @since 2.0 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerSupport.NONE) public final Single> toSortedList(final Comparator comparator, int capacityHint) { @@ -17142,6 +17474,7 @@ public final Single> toSortedList(int capacityHint) { * @see ReactiveX operators documentation: SubscribeOn */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable unsubscribeOn(Scheduler scheduler) { @@ -17352,6 +17685,7 @@ public final Flowable> window(long timespan, long timeskip, TimeUnit * @see ReactiveX operators documentation: Window */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable> window(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, int bufferSize) { @@ -17630,6 +17964,7 @@ public final Flowable> window(long timespan, TimeUnit unit, * @see ReactiveX operators documentation: Window */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.CUSTOM) public final Flowable> window( @@ -17698,6 +18033,7 @@ public final Flowable> window(Publisher boundaryIndicator) { * @see ReactiveX operators documentation: Window */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable> window(Publisher boundaryIndicator, int bufferSize) { @@ -17774,6 +18110,7 @@ public final Flowable> window( * @see ReactiveX operators documentation: Window */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable> window( @@ -17847,6 +18184,7 @@ public final Flowable> window(Callable> b * @see ReactiveX operators documentation: Window */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable> window(Callable> boundaryIndicatorSupplier, int bufferSize) { @@ -17884,6 +18222,7 @@ public final Flowable> window(Callable> b * @see ReactiveX operators documentation: CombineLatest */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable withLatestFrom(Publisher other, @@ -17921,6 +18260,7 @@ public final Flowable withLatestFrom(Publisher other, * @since 2.0 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable withLatestFrom(Publisher source1, Publisher source2, @@ -17960,6 +18300,7 @@ public final Flowable withLatestFrom(Publisher source1, Publi * @since 2.0 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable withLatestFrom( @@ -18004,6 +18345,7 @@ public final Flowable withLatestFrom( * @since 2.0 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable withLatestFrom( @@ -18042,6 +18384,7 @@ public final Flowable withLatestFrom( * @since 2.0 */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable withLatestFrom(Publisher[] others, Function combiner) { @@ -18074,6 +18417,7 @@ public final Flowable withLatestFrom(Publisher[] others, Function Flowable withLatestFrom(Iterable> others, Function combiner) { @@ -18113,6 +18457,7 @@ public final Flowable withLatestFrom(Iterable> oth * @see ReactiveX operators documentation: Zip */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable zipWith(Iterable other, BiFunction zipper) { @@ -18161,6 +18506,7 @@ public final Flowable zipWith(Iterable other, BiFunctionReactiveX operators documentation: Zip */ @CheckReturnValue + @NonNull @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerSupport.NONE) public final Flowable zipWith(Publisher other, BiFunction zipper) { diff --git a/src/main/java/io/reactivex/FlowableSubscriber.java b/src/main/java/io/reactivex/FlowableSubscriber.java index 2ef1019acf..e2636406e1 100644 --- a/src/main/java/io/reactivex/FlowableSubscriber.java +++ b/src/main/java/io/reactivex/FlowableSubscriber.java @@ -17,7 +17,7 @@ import org.reactivestreams.*; /** - * Represents a Reactive-Streams inspired Subscriber that is RxJava 2 only + * Represents a Reactive Streams inspired Subscriber that is RxJava 2 only * and weakens rules §1.3 and §3.9 of the specification for gaining performance. * *

    History: 2.0.7 - experimental; 2.1 - beta diff --git a/src/main/java/io/reactivex/Maybe.java b/src/main/java/io/reactivex/Maybe.java index b1d34260f1..aecb501348 100644 --- a/src/main/java/io/reactivex/Maybe.java +++ b/src/main/java/io/reactivex/Maybe.java @@ -124,6 +124,7 @@ public abstract class Maybe implements MaybeSource { * @return the new Maybe instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe amb(final Iterable> sources) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -174,6 +175,7 @@ public static Maybe ambArray(final MaybeSource... sources) { */ @BackpressureSupport(BackpressureKind.FULL) @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Flowable concat(Iterable> sources) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -201,6 +203,7 @@ public static Flowable concat(Iterable */ @BackpressureSupport(BackpressureKind.FULL) @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static Flowable concat(MaybeSource source1, MaybeSource source2) { @@ -232,6 +235,7 @@ public static Flowable concat(MaybeSource source1, MaybeSour */ @BackpressureSupport(BackpressureKind.FULL) @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static Flowable concat( @@ -267,6 +271,7 @@ public static Flowable concat( */ @BackpressureSupport(BackpressureKind.FULL) @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static Flowable concat( @@ -322,6 +327,7 @@ public static Flowable concat(Publisher Flowable concat(Publisher> sources, int prefetch) { @@ -346,6 +352,7 @@ public static Flowable concat(Publisher Flowable concatArray(MaybeSource... sources) { @@ -434,6 +441,7 @@ public static Flowable concatArrayEager(MaybeSource... sourc @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Flowable concatDelayError(Iterable> sources) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -557,6 +565,7 @@ public static Flowable concatEager(Publisher Maybe create(MaybeOnSubscribe onSubscribe) { ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null"); @@ -576,6 +585,7 @@ public static Maybe create(MaybeOnSubscribe onSubscribe) { * @return the new Maybe instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe defer(final Callable> maybeSupplier) { ObjectHelper.requireNonNull(maybeSupplier, "maybeSupplier is null"); @@ -620,6 +630,7 @@ public static Maybe empty() { * @see ReactiveX operators documentation: Throw */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe error(Throwable exception) { ObjectHelper.requireNonNull(exception, "exception is null"); @@ -645,6 +656,7 @@ public static Maybe error(Throwable exception) { * @see ReactiveX operators documentation: Throw */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe error(Callable supplier) { ObjectHelper.requireNonNull(supplier, "errorSupplier is null"); @@ -671,6 +683,7 @@ public static Maybe error(Callable supplier) { * @throws NullPointerException if run is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe fromAction(final Action run) { ObjectHelper.requireNonNull(run, "run is null"); @@ -690,6 +703,7 @@ public static Maybe fromAction(final Action run) { * @throws NullPointerException if completable is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe fromCompletable(CompletableSource completableSource) { ObjectHelper.requireNonNull(completableSource, "completableSource is null"); @@ -709,6 +723,7 @@ public static Maybe fromCompletable(CompletableSource completableSource) * @throws NullPointerException if single is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe fromSingle(SingleSource singleSource) { ObjectHelper.requireNonNull(singleSource, "singleSource is null"); @@ -750,6 +765,7 @@ public static Maybe fromSingle(SingleSource singleSource) { * @return a new Maybe instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe fromCallable(@NonNull final Callable callable) { ObjectHelper.requireNonNull(callable, "callable is null"); @@ -783,6 +799,7 @@ public static Maybe fromCallable(@NonNull final Callable cal * @see ReactiveX operators documentation: From */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe fromFuture(Future future) { ObjectHelper.requireNonNull(future, "future is null"); @@ -820,6 +837,7 @@ public static Maybe fromFuture(Future future) { * @see ReactiveX operators documentation: From */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe fromFuture(Future future, long timeout, TimeUnit unit) { ObjectHelper.requireNonNull(future, "future is null"); @@ -840,6 +858,7 @@ public static Maybe fromFuture(Future future, long timeout, * @throws NullPointerException if run is null */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe fromRunnable(final Runnable run) { ObjectHelper.requireNonNull(run, "run is null"); @@ -866,6 +885,7 @@ public static Maybe fromRunnable(final Runnable run) { * @see ReactiveX operators documentation: Just */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe just(T item) { ObjectHelper.requireNonNull(item, "item is null"); @@ -970,6 +990,7 @@ public static Flowable merge(Publisher */ @BackpressureSupport(BackpressureKind.FULL) @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings({ "unchecked", "rawtypes" }) public static Flowable merge(Publisher> sources, int maxConcurrency) { @@ -1002,6 +1023,7 @@ public static Flowable merge(Publisher * @see ReactiveX operators documentation: Merge */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings({ "unchecked", "rawtypes" }) public static Maybe merge(MaybeSource> source) { @@ -1047,6 +1069,7 @@ public static Maybe merge(MaybeSource> */ @BackpressureSupport(BackpressureKind.FULL) @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static Flowable merge( @@ -1097,6 +1120,7 @@ public static Flowable merge( */ @BackpressureSupport(BackpressureKind.FULL) @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static Flowable merge( @@ -1151,6 +1175,7 @@ public static Flowable merge( */ @BackpressureSupport(BackpressureKind.FULL) @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static Flowable merge( @@ -1193,6 +1218,7 @@ public static Flowable merge( */ @BackpressureSupport(BackpressureKind.FULL) @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static Flowable mergeArray(MaybeSource... sources) { @@ -1347,6 +1373,7 @@ public static Flowable mergeDelayError(Publisher Flowable mergeDelayError(Publisher> sources, int maxConcurrency) { ObjectHelper.requireNonNull(sources, "source is null"); @@ -1385,6 +1412,7 @@ public static Flowable mergeDelayError(Publisher Flowable mergeDelayError(MaybeSource source1, MaybeSource source2) { ObjectHelper.requireNonNull(source1, "source1 is null"); @@ -1426,6 +1454,7 @@ public static Flowable mergeDelayError(MaybeSource source1, @SuppressWarnings({ "unchecked" }) @BackpressureSupport(BackpressureKind.FULL) @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Flowable mergeDelayError(MaybeSource source1, MaybeSource source2, MaybeSource source3) { @@ -1471,6 +1500,7 @@ public static Flowable mergeDelayError(MaybeSource source1, @SuppressWarnings({ "unchecked" }) @BackpressureSupport(BackpressureKind.FULL) @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Flowable mergeDelayError( MaybeSource source1, MaybeSource source2, @@ -1554,6 +1584,7 @@ public static Single sequenceEqual(MaybeSource source1 * @see ReactiveX operators documentation: SequenceEqual */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Single sequenceEqual(MaybeSource source1, MaybeSource source2, BiPredicate isEqual) { @@ -1604,6 +1635,7 @@ public static Maybe timer(long delay, TimeUnit unit) { * @see ReactiveX operators documentation: Timer */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.CUSTOM) public static Maybe timer(long delay, TimeUnit unit, Scheduler scheduler) { ObjectHelper.requireNonNull(unit, "unit is null"); @@ -1624,6 +1656,7 @@ public static Maybe timer(long delay, TimeUnit unit, Scheduler scheduler) * @return the new Maybe instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe unsafeCreate(MaybeSource onSubscribe) { if (onSubscribe instanceof Maybe) { @@ -1690,6 +1723,7 @@ public static Maybe using(Callable resourceSupplier, * @see ReactiveX operators documentation: Using */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe using(Callable resourceSupplier, Function> sourceSupplier, @@ -1712,6 +1746,7 @@ public static Maybe using(Callable resourceSupplier, * @return the Maybe wrapper or the source cast to Maybe (if possible) */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe wrap(MaybeSource source) { if (source instanceof Maybe) { @@ -1749,6 +1784,7 @@ public static Maybe wrap(MaybeSource source) { * @see ReactiveX operators documentation: Zip */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe zip(Iterable> sources, Function zipper) { ObjectHelper.requireNonNull(zipper, "zipper is null"); @@ -1783,6 +1819,7 @@ public static Maybe zip(Iterable> s */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe zip( MaybeSource source1, MaybeSource source2, @@ -1822,6 +1859,7 @@ public static Maybe zip( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe zip( MaybeSource source1, MaybeSource source2, MaybeSource source3, @@ -1865,6 +1903,7 @@ public static Maybe zip( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe zip( MaybeSource source1, MaybeSource source2, MaybeSource source3, @@ -1913,6 +1952,7 @@ public static Maybe zip( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe zip( MaybeSource source1, MaybeSource source2, MaybeSource source3, @@ -1965,6 +2005,7 @@ public static Maybe zip( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe zip( MaybeSource source1, MaybeSource source2, MaybeSource source3, @@ -2021,6 +2062,7 @@ public static Maybe zip( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe zip( MaybeSource source1, MaybeSource source2, MaybeSource source3, @@ -2082,6 +2124,7 @@ public static Maybe zip( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe zip( MaybeSource source1, MaybeSource source2, MaybeSource source3, @@ -2147,6 +2190,7 @@ public static Maybe zip( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe zip( MaybeSource source1, MaybeSource source2, MaybeSource source3, @@ -2194,6 +2238,7 @@ public static Maybe zip( * @see ReactiveX operators documentation: Zip */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Maybe zipArray(Function zipper, MaybeSource... sources) { @@ -2227,6 +2272,7 @@ public static Maybe zipArray(Function z */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe ambWith(MaybeSource other) { ObjectHelper.requireNonNull(other, "other is null"); @@ -2335,6 +2381,7 @@ public final Maybe cache() { * @return the new Maybe instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe cast(final Class clazz) { ObjectHelper.requireNonNull(clazz, "clazz is null"); @@ -2383,6 +2430,7 @@ public final Maybe compose(MaybeTransformer trans * @see ReactiveX operators documentation: FlatMap */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe concatMap(Function> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); @@ -2409,6 +2457,7 @@ public final Maybe concatMap(Function concatWith(MaybeSource other) { ObjectHelper.requireNonNull(other, "other is null"); @@ -2432,6 +2481,7 @@ public final Flowable concatWith(MaybeSource other) { * @see ReactiveX operators documentation: Contains */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Single contains(final Object item) { ObjectHelper.requireNonNull(item, "item is null"); @@ -2439,7 +2489,7 @@ public final Single contains(final Object item) { } /** - * Returns a Maybe that counts the total number of items emitted (0 or 1) by the source Maybe and emits + * Returns a Single that counts the total number of items emitted (0 or 1) by the source Maybe and emits * this count as a 64-bit Long. *

    * @@ -2480,9 +2530,10 @@ public final Single count() { * @see ReactiveX operators documentation: DefaultIfEmpty */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe defaultIfEmpty(T defaultItem) { - ObjectHelper.requireNonNull(defaultItem, "item is null"); + ObjectHelper.requireNonNull(defaultItem, "defaultItem is null"); return switchIfEmpty(just(defaultItem)); } @@ -2529,6 +2580,7 @@ public final Maybe delay(long delay, TimeUnit unit) { * @see ReactiveX operators documentation: Delay */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.CUSTOM) public final Maybe delay(long delay, TimeUnit unit, Scheduler scheduler) { ObjectHelper.requireNonNull(unit, "unit is null"); @@ -2559,6 +2611,7 @@ public final Maybe delay(long delay, TimeUnit unit, Scheduler scheduler) { * @see ReactiveX operators documentation: Delay */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) public final Maybe delay(Publisher delayIndicator) { @@ -2584,6 +2637,7 @@ public final Maybe delay(Publisher delayIndicator) { */ @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe delaySubscription(Publisher subscriptionIndicator) { ObjectHelper.requireNonNull(subscriptionIndicator, "subscriptionIndicator is null"); @@ -2652,9 +2706,10 @@ public final Maybe delaySubscription(long delay, TimeUnit unit, Scheduler sch * @since 2.1 */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe doAfterSuccess(Consumer onAfterSuccess) { - ObjectHelper.requireNonNull(onAfterSuccess, "doAfterSuccess is null"); + ObjectHelper.requireNonNull(onAfterSuccess, "onAfterSuccess is null"); return RxJavaPlugins.onAssembly(new MaybeDoAfterSuccess(this, onAfterSuccess)); } @@ -2676,6 +2731,7 @@ public final Maybe doAfterSuccess(Consumer onAfterSuccess) { * @see ReactiveX operators documentation: Do */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe doAfterTerminate(Action onAfterTerminate) { return RxJavaPlugins.onAssembly(new MaybePeek(this, @@ -2705,6 +2761,7 @@ public final Maybe doAfterTerminate(Action onAfterTerminate) { * @since 2.1 */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe doFinally(Action onFinally) { ObjectHelper.requireNonNull(onFinally, "onFinally is null"); @@ -2723,6 +2780,7 @@ public final Maybe doFinally(Action onFinally) { * @return the new Maybe instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe doOnDispose(Action onDispose) { return RxJavaPlugins.onAssembly(new MaybePeek(this, @@ -2750,6 +2808,7 @@ public final Maybe doOnDispose(Action onDispose) { * @see ReactiveX operators documentation: Do */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe doOnComplete(Action onComplete) { return RxJavaPlugins.onAssembly(new MaybePeek(this, @@ -2775,6 +2834,7 @@ public final Maybe doOnComplete(Action onComplete) { * @return the new Maybe instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe doOnError(Consumer onError) { return RxJavaPlugins.onAssembly(new MaybePeek(this, @@ -2819,6 +2879,7 @@ public final Maybe doOnEvent(BiConsumer onEvent * @return the new Maybe instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe doOnSubscribe(Consumer onSubscribe) { return RxJavaPlugins.onAssembly(new MaybePeek(this, @@ -2831,6 +2892,33 @@ public final Maybe doOnSubscribe(Consumer onSubscribe) { )); } + /** + * Returns a Maybe instance that calls the given onTerminate callback + * just before this Maybe completes normally or with an exception. + *

    + * + *

    + * This differs from {@code doAfterTerminate} in that this happens before the {@code onComplete} or + * {@code onError} notification. + *

    + *
    Scheduler:
    + *
    {@code doOnTerminate} does not operate by default on a particular {@link Scheduler}.
    + *
    + * @param onTerminate the action to invoke when the consumer calls {@code onComplete} or {@code onError} + * @return the new Maybe instance + * @see ReactiveX operators documentation: Do + * @see #doOnTerminate(Action) + * @since 2.2.7 - experimental + */ + @Experimental + @CheckReturnValue + @NonNull + @SchedulerSupport(SchedulerSupport.NONE) + public final Maybe doOnTerminate(final Action onTerminate) { + ObjectHelper.requireNonNull(onTerminate, "onTerminate is null"); + return RxJavaPlugins.onAssembly(new MaybeDoOnTerminate(this, onTerminate)); + } + /** * Calls the shared consumer with the success value sent via onSuccess for each * MaybeObserver that subscribes to the current Maybe. @@ -2844,11 +2932,12 @@ public final Maybe doOnSubscribe(Consumer onSubscribe) { * @return the new Maybe instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe doOnSuccess(Consumer onSuccess) { return RxJavaPlugins.onAssembly(new MaybePeek(this, Functions.emptyConsumer(), // onSubscribe - ObjectHelper.requireNonNull(onSuccess, "onSubscribe is null"), + ObjectHelper.requireNonNull(onSuccess, "onSuccess is null"), Functions.emptyConsumer(), // onError Functions.EMPTY_ACTION, // onComplete Functions.EMPTY_ACTION, // (onSuccess | onError | onComplete) @@ -2874,6 +2963,7 @@ public final Maybe doOnSuccess(Consumer onSuccess) { * @see ReactiveX operators documentation: Filter */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe filter(Predicate predicate) { ObjectHelper.requireNonNull(predicate, "predicate is null"); @@ -2898,6 +2988,7 @@ public final Maybe filter(Predicate predicate) { * @see ReactiveX operators documentation: FlatMap */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe flatMap(Function> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); @@ -2926,6 +3017,7 @@ public final Maybe flatMap(FunctionReactiveX operators documentation: FlatMap */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe flatMap( Function> onSuccessMapper, @@ -2960,6 +3052,7 @@ public final Maybe flatMap( * @see ReactiveX operators documentation: FlatMap */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe flatMap(Function> mapper, BiFunction resultSelector) { @@ -2969,8 +3062,8 @@ public final Maybe flatMap(Function * *
    @@ -2990,6 +3083,7 @@ public final Maybe flatMap(Function Flowable flattenAsFlowable(final Function> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); @@ -2997,7 +3091,8 @@ public final Flowable flattenAsFlowable(final Function * *
    @@ -3014,6 +3109,7 @@ public final Flowable flattenAsFlowable(final FunctionReactiveX operators documentation: FlatMap */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Observable flattenAsObservable(final Function> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); @@ -3037,6 +3133,7 @@ public final Observable flattenAsObservable(final FunctionReactiveX operators documentation: FlatMap */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Observable flatMapObservable(Function> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); @@ -3064,6 +3161,7 @@ public final Observable flatMapObservable(Function Flowable flatMapPublisher(Function> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); @@ -3089,6 +3187,7 @@ public final Flowable flatMapPublisher(FunctionReactiveX operators documentation: FlatMap */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Single flatMapSingle(final Function> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); @@ -3116,6 +3215,7 @@ public final Single flatMapSingle(final Function Maybe flatMapSingleElement(final Function> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); @@ -3139,6 +3239,7 @@ public final Maybe flatMapSingleElement(final FunctionReactiveX operators documentation: FlatMap */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Completable flatMapCompletable(final Function mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); @@ -3348,9 +3449,10 @@ public final Single isEmpty() { * @see #compose(MaybeTransformer) */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe lift(final MaybeOperator lift) { - ObjectHelper.requireNonNull(lift, "onLift is null"); + ObjectHelper.requireNonNull(lift, "lift is null"); return RxJavaPlugins.onAssembly(new MaybeLift(this, lift)); } @@ -3371,6 +3473,7 @@ public final Maybe lift(final MaybeOperator lift) * @see ReactiveX operators documentation: Map */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe map(Function mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); @@ -3418,6 +3521,7 @@ public final Single> materialize() { */ @BackpressureSupport(BackpressureKind.FULL) @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Flowable mergeWith(MaybeSource other) { ObjectHelper.requireNonNull(other, "other is null"); @@ -3443,6 +3547,7 @@ public final Flowable mergeWith(MaybeSource other) { * @see #subscribeOn */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.CUSTOM) public final Maybe observeOn(final Scheduler scheduler) { ObjectHelper.requireNonNull(scheduler, "scheduler is null"); @@ -3466,6 +3571,7 @@ public final Maybe observeOn(final Scheduler scheduler) { * @see ReactiveX operators documentation: Filter */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe ofType(final Class clazz) { ObjectHelper.requireNonNull(clazz, "clazz is null"); @@ -3486,6 +3592,7 @@ public final Maybe ofType(final Class clazz) { * @return the value returned by the convert function */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final R to(Function, R> convert) { try { @@ -3549,6 +3656,7 @@ public final Observable toObservable() { * @return the new Single instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Single toSingle(T defaultValue) { ObjectHelper.requireNonNull(defaultValue, "defaultValue is null"); @@ -3577,7 +3685,7 @@ public final Single toSingle() { *
    Scheduler:
    *
    {@code onErrorComplete} does not operate by default on a particular {@link Scheduler}.
    *
    - * @return the new Completable instance + * @return the new Maybe instance */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -3594,9 +3702,10 @@ public final Maybe onErrorComplete() { *
    * @param predicate the predicate to call when an Throwable is emitted which should return true * if the Throwable should be swallowed and replaced with an onComplete. - * @return the new Completable instance + * @return the new Maybe instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe onErrorComplete(final Predicate predicate) { ObjectHelper.requireNonNull(predicate, "predicate is null"); @@ -3624,6 +3733,7 @@ public final Maybe onErrorComplete(final Predicate predica * @see ReactiveX operators documentation: Catch */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe onErrorResumeNext(final MaybeSource next) { ObjectHelper.requireNonNull(next, "next is null"); @@ -3650,6 +3760,7 @@ public final Maybe onErrorResumeNext(final MaybeSource next) { * @see ReactiveX operators documentation: Catch */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe onErrorResumeNext(Function> resumeFunction) { ObjectHelper.requireNonNull(resumeFunction, "resumeFunction is null"); @@ -3676,6 +3787,7 @@ public final Maybe onErrorResumeNext(FunctionReactiveX operators documentation: Catch */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe onErrorReturn(Function valueSupplier) { ObjectHelper.requireNonNull(valueSupplier, "valueSupplier is null"); @@ -3701,6 +3813,7 @@ public final Maybe onErrorReturn(Function val * @see ReactiveX operators documentation: Catch */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe onErrorReturnItem(final T item) { ObjectHelper.requireNonNull(item, "item is null"); @@ -3730,6 +3843,7 @@ public final Maybe onErrorReturnItem(final T item) { * @see ReactiveX operators documentation: Catch */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe onExceptionResumeNext(final MaybeSource next) { ObjectHelper.requireNonNull(next, "next is null"); @@ -3870,7 +3984,7 @@ public final Flowable repeatWhen(final Function, ? e *
    {@code retry} does not operate by default on a particular {@link Scheduler}.
    *
    * - * @return the nww Maybe instance + * @return the new Maybe instance * @see ReactiveX operators documentation: Retry */ @CheckReturnValue @@ -3892,7 +4006,7 @@ public final Maybe retry() { * @param predicate * the predicate that determines if a resubscription may happen in case of a specific exception * and retry count - * @return the nww Maybe instance + * @return the new Maybe instance * @see #retry() * @see ReactiveX operators documentation: Retry */ @@ -3917,7 +4031,7 @@ public final Maybe retry(BiPredicate pred *
    * * @param count - * number of retry attempts before failing + * the number of times to resubscribe if the current Maybe fails * @return the new Maybe instance * @see ReactiveX operators documentation: Retry */ @@ -3934,7 +4048,7 @@ public final Maybe retry(long count) { *
    Scheduler:
    *
    {@code retry} does not operate by default on a particular {@link Scheduler}.
    *
- * @param times the number of times to repeat + * @param times the number of times to resubscribe if the current Maybe fails * @param predicate the predicate called with the failure Throwable and should return true to trigger a retry. * @return the new Maybe instance */ @@ -3970,6 +4084,7 @@ public final Maybe retry(Predicate predicate) { * @return the new Maybe instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe retryUntil(final BooleanSupplier stop) { ObjectHelper.requireNonNull(stop, "stop is null"); @@ -4152,6 +4267,7 @@ public final Disposable subscribe(Consumer onSuccess, ConsumerReactiveX operators documentation: Subscribe */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Disposable subscribe(Consumer onSuccess, Consumer onError, Action onComplete) { @@ -4208,6 +4324,7 @@ public final void subscribe(MaybeObserver observer) { * @see #observeOn */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.CUSTOM) public final Maybe subscribeOn(Scheduler scheduler) { ObjectHelper.requireNonNull(scheduler, "scheduler is null"); @@ -4260,6 +4377,7 @@ public final > E subscribeWith(E observer) { * alternate MaybeSource if the source Maybe is empty. */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe switchIfEmpty(MaybeSource other) { ObjectHelper.requireNonNull(other, "other is null"); @@ -4283,6 +4401,7 @@ public final Maybe switchIfEmpty(MaybeSource other) { * @since 2.2 */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Single switchIfEmpty(SingleSource other) { ObjectHelper.requireNonNull(other, "other is null"); @@ -4308,6 +4427,7 @@ public final Single switchIfEmpty(SingleSource other) { * @see ReactiveX operators documentation: TakeUntil */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe takeUntil(MaybeSource other) { ObjectHelper.requireNonNull(other, "other is null"); @@ -4337,6 +4457,7 @@ public final Maybe takeUntil(MaybeSource other) { */ @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe takeUntil(Publisher other) { ObjectHelper.requireNonNull(other, "other is null"); @@ -4370,7 +4491,7 @@ public final Maybe timeout(long timeout, TimeUnit timeUnit) { /** * Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted * item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, - * the resulting Maybe begins instead to mirror a fallback MaybeSource. + * the source MaybeSource is disposed and resulting Maybe begins instead to mirror a fallback MaybeSource. *

* *

@@ -4388,16 +4509,18 @@ public final Maybe timeout(long timeout, TimeUnit timeUnit) { * @see ReactiveX operators documentation: Timeout */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.COMPUTATION) public final Maybe timeout(long timeout, TimeUnit timeUnit, MaybeSource fallback) { - ObjectHelper.requireNonNull(fallback, "other is null"); + ObjectHelper.requireNonNull(fallback, "fallback is null"); return timeout(timeout, timeUnit, Schedulers.computation(), fallback); } /** * Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted * item using a specified Scheduler. If the next item isn't emitted within the specified timeout duration - * starting from its predecessor, the resulting Maybe begins instead to mirror a fallback MaybeSource. + * starting from its predecessor, the source MaybeSource is disposed and resulting Maybe begins instead + * to mirror a fallback MaybeSource. *

* *

@@ -4417,6 +4540,7 @@ public final Maybe timeout(long timeout, TimeUnit timeUnit, MaybeSourceReactiveX operators documentation: Timeout */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.CUSTOM) public final Maybe timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler, MaybeSource fallback) { ObjectHelper.requireNonNull(fallback, "fallback is null"); @@ -4463,6 +4587,7 @@ public final Maybe timeout(long timeout, TimeUnit timeUnit, Scheduler schedul * @return the new Maybe instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe timeout(MaybeSource timeoutIndicator) { ObjectHelper.requireNonNull(timeoutIndicator, "timeoutIndicator is null"); @@ -4484,6 +4609,7 @@ public final Maybe timeout(MaybeSource timeoutIndicator) { * @return the new Maybe instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe timeout(MaybeSource timeoutIndicator, MaybeSource fallback) { ObjectHelper.requireNonNull(timeoutIndicator, "timeoutIndicator is null"); @@ -4508,6 +4634,7 @@ public final Maybe timeout(MaybeSource timeoutIndicator, MaybeSource Maybe timeout(Publisher timeoutIndicator) { ObjectHelper.requireNonNull(timeoutIndicator, "timeoutIndicator is null"); @@ -4533,6 +4660,7 @@ public final Maybe timeout(Publisher timeoutIndicator) { */ @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe timeout(Publisher timeoutIndicator, MaybeSource fallback) { ObjectHelper.requireNonNull(timeoutIndicator, "timeoutIndicator is null"); @@ -4552,6 +4680,7 @@ public final Maybe timeout(Publisher timeoutIndicator, MaybeSource unsubscribeOn(final Scheduler scheduler) { ObjectHelper.requireNonNull(scheduler, "scheduler is null"); @@ -4585,6 +4714,7 @@ public final Maybe unsubscribeOn(final Scheduler scheduler) { * @see ReactiveX operators documentation: Zip */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final Maybe zipWith(MaybeSource other, BiFunction zipper) { ObjectHelper.requireNonNull(other, "other is null"); diff --git a/src/main/java/io/reactivex/Observable.java b/src/main/java/io/reactivex/Observable.java index ef177b5c6a..43f1f14483 100644 --- a/src/main/java/io/reactivex/Observable.java +++ b/src/main/java/io/reactivex/Observable.java @@ -42,7 +42,7 @@ * Many operators in the class accept {@code ObservableSource}(s), the base reactive interface * for such non-backpressured flows, which {@code Observable} itself implements as well. *

- * The Observable's operators, by default, run with a buffer size of 128 elements (see {@link Flowable#bufferSize()}, + * The Observable's operators, by default, run with a buffer size of 128 elements (see {@link Flowable#bufferSize()}), * that can be overridden globally via the system parameter {@code rx2.buffer-size}. Most operators, however, have * overloads that allow setting their internal buffer size explicitly. *

@@ -51,7 +51,7 @@ * *

* The design of this class was derived from the - * Reactive-Streams design and specification + * Reactive Streams design and specification * by removing any backpressure-related infrastructure and implementation detail, replacing the * {@code org.reactivestreams.Subscription} with {@link Disposable} as the primary means to dispose of * a flow. @@ -84,12 +84,12 @@ * System.out.println("Done!"); * } * }); - * + * * Thread.sleep(500); * // the sequence can now be disposed via dispose() * d.dispose(); * - * + * * @param * the type of the items emitted by the Observable * @see Flowable @@ -116,6 +116,7 @@ public abstract class Observable implements ObservableSource { * @see ReactiveX operators documentation: Amb */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable amb(Iterable> sources) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -142,6 +143,7 @@ public static Observable amb(Iterable Observable ambArray(ObservableSource... sources) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -289,6 +291,7 @@ public static Observable combineLatest(IterableReactiveX operators documentation: CombineLatest */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable combineLatest(Iterable> sources, Function combiner, int bufferSize) { @@ -381,6 +384,7 @@ public static Observable combineLatest(ObservableSource[] * @see ReactiveX operators documentation: CombineLatest */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable combineLatest(ObservableSource[] sources, Function combiner, int bufferSize) { @@ -426,6 +430,7 @@ public static Observable combineLatest(ObservableSource[] */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable combineLatest( ObservableSource source1, ObservableSource source2, @@ -468,6 +473,7 @@ public static Observable combineLatest( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable combineLatest( ObservableSource source1, ObservableSource source2, @@ -515,6 +521,7 @@ public static Observable combineLatest( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable combineLatest( ObservableSource source1, ObservableSource source2, @@ -566,6 +573,7 @@ public static Observable combineLatest( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable combineLatest( ObservableSource source1, ObservableSource source2, @@ -622,6 +630,7 @@ public static Observable combineLatest( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable combineLatest( ObservableSource source1, ObservableSource source2, @@ -682,6 +691,7 @@ public static Observable combineLatest( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable combineLatest( ObservableSource source1, ObservableSource source2, @@ -747,6 +757,7 @@ public static Observable combineLatest( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable combineLatest( ObservableSource source1, ObservableSource source2, @@ -816,6 +827,7 @@ public static Observable combineLatest( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable combineLatest( ObservableSource source1, ObservableSource source2, @@ -962,6 +974,7 @@ public static Observable combineLatestDelayError(FunctionReactiveX operators documentation: CombineLatest */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable combineLatestDelayError(ObservableSource[] sources, Function combiner, int bufferSize) { @@ -1057,6 +1070,7 @@ public static Observable combineLatestDelayError(IterableReactiveX operators documentation: CombineLatest */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable combineLatestDelayError(Iterable> sources, Function combiner, int bufferSize) { @@ -1084,6 +1098,7 @@ public static Observable combineLatestDelayError(Iterable Observable concat(Iterable> sources) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -1134,6 +1149,7 @@ public static Observable concat(ObservableSource Observable concat(ObservableSource> sources, int prefetch) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -1162,6 +1178,7 @@ public static Observable concat(ObservableSource Observable concat(ObservableSource source1, ObservableSource source2) { ObjectHelper.requireNonNull(source1, "source1 is null"); @@ -1192,6 +1209,7 @@ public static Observable concat(ObservableSource source1, Ob */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable concat( ObservableSource source1, ObservableSource source2, @@ -1227,6 +1245,7 @@ public static Observable concat( */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable concat( ObservableSource source1, ObservableSource source2, @@ -1259,7 +1278,7 @@ public static Observable concat( public static Observable concatArray(ObservableSource... sources) { if (sources.length == 0) { return empty(); - } else + } if (sources.length == 1) { return wrap((ObservableSource)sources[0]); } @@ -1286,7 +1305,7 @@ public static Observable concatArray(ObservableSource... sou public static Observable concatArrayDelayError(ObservableSource... sources) { if (sources.length == 0) { return empty(); - } else + } if (sources.length == 1) { return (Observable)wrap(sources[0]); } @@ -1410,6 +1429,7 @@ public static Observable concatArrayEagerDelayError(int maxConcurrency, i * @return the new ObservableSource with the concatenating behavior */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable concatDelayError(Iterable> sources) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -1455,6 +1475,7 @@ public static Observable concatDelayError(ObservableSource Observable concatDelayError(ObservableSource> sources, int prefetch, boolean tillTheEnd) { ObjectHelper.requireNonNull(sources, "sources is null"); @@ -1607,6 +1628,7 @@ public static Observable concatEager(Iterable Observable create(ObservableOnSubscribe source) { ObjectHelper.requireNonNull(source, "source is null"); @@ -1638,6 +1660,7 @@ public static Observable create(ObservableOnSubscribe source) { * @see ReactiveX operators documentation: Defer */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable defer(Callable> supplier) { ObjectHelper.requireNonNull(supplier, "supplier is null"); @@ -1686,6 +1709,7 @@ public static Observable empty() { * @see ReactiveX operators documentation: Throw */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable error(Callable errorSupplier) { ObjectHelper.requireNonNull(errorSupplier, "errorSupplier is null"); @@ -1711,9 +1735,10 @@ public static Observable error(Callable errorSupplie * @see ReactiveX operators documentation: Throw */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable error(final Throwable exception) { - ObjectHelper.requireNonNull(exception, "e is null"); + ObjectHelper.requireNonNull(exception, "exception is null"); return error(Functions.justCallable(exception)); } @@ -1735,11 +1760,12 @@ public static Observable error(final Throwable exception) { */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) + @NonNull public static Observable fromArray(T... items) { ObjectHelper.requireNonNull(items, "items is null"); if (items.length == 0) { return empty(); - } else + } if (items.length == 1) { return just(items[0]); } @@ -1775,6 +1801,7 @@ public static Observable fromArray(T... items) { * @since 2.0 */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable fromCallable(Callable supplier) { ObjectHelper.requireNonNull(supplier, "supplier is null"); @@ -1808,6 +1835,7 @@ public static Observable fromCallable(Callable supplier) { * @see ReactiveX operators documentation: From */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable fromFuture(Future future) { ObjectHelper.requireNonNull(future, "future is null"); @@ -1845,6 +1873,7 @@ public static Observable fromFuture(Future future) { * @see ReactiveX operators documentation: From */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable fromFuture(Future future, long timeout, TimeUnit unit) { ObjectHelper.requireNonNull(future, "future is null"); @@ -1886,6 +1915,7 @@ public static Observable fromFuture(Future future, long time * @see ReactiveX operators documentation: From */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.CUSTOM) public static Observable fromFuture(Future future, long timeout, TimeUnit unit, Scheduler scheduler) { ObjectHelper.requireNonNull(scheduler, "scheduler is null"); @@ -1921,6 +1951,7 @@ public static Observable fromFuture(Future future, long time * @see ReactiveX operators documentation: From */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.CUSTOM) public static Observable fromFuture(Future future, Scheduler scheduler) { ObjectHelper.requireNonNull(scheduler, "scheduler is null"); @@ -1946,6 +1977,7 @@ public static Observable fromFuture(Future future, Scheduler * @see ReactiveX operators documentation: From */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable fromIterable(Iterable source) { ObjectHelper.requireNonNull(source, "source is null"); @@ -1953,12 +1985,12 @@ public static Observable fromIterable(Iterable source) { } /** - * Converts an arbitrary Reactive-Streams Publisher into an Observable. + * Converts an arbitrary Reactive Streams Publisher into an Observable. *

* *

* The {@link Publisher} must follow the - * Reactive-Streams specification. + * Reactive Streams specification. * Violating the specification may result in undefined behavior. *

* If possible, use {@link #create(ObservableOnSubscribe)} to create a @@ -1982,6 +2014,7 @@ public static Observable fromIterable(Iterable source) { */ @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable fromPublisher(Publisher publisher) { ObjectHelper.requireNonNull(publisher, "publisher is null"); @@ -2010,9 +2043,10 @@ public static Observable fromPublisher(Publisher publisher) * @return the new Observable instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable generate(final Consumer> generator) { - ObjectHelper.requireNonNull(generator, "generator is null"); + ObjectHelper.requireNonNull(generator, "generator is null"); return generate(Functions.nullSupplier(), ObservableInternalHelper.simpleGenerator(generator), Functions.emptyConsumer()); } @@ -2041,9 +2075,10 @@ public static Observable generate(final Consumer> generator) { * @return the new Observable instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable generate(Callable initialState, final BiConsumer> generator) { - ObjectHelper.requireNonNull(generator, "generator is null"); + ObjectHelper.requireNonNull(generator, "generator is null"); return generate(initialState, ObservableInternalHelper.simpleBiGenerator(generator), Functions.emptyConsumer()); } @@ -2073,12 +2108,13 @@ public static Observable generate(Callable initialState, final BiCo * @return the new Observable instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable generate( final Callable initialState, final BiConsumer> generator, Consumer disposeState) { - ObjectHelper.requireNonNull(generator, "generator is null"); + ObjectHelper.requireNonNull(generator, "generator is null"); return generate(initialState, ObservableInternalHelper.simpleBiGenerator(generator), disposeState); } @@ -2139,11 +2175,12 @@ public static Observable generate(Callable initialState, BiFunction * @return the new Observable instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable generate(Callable initialState, BiFunction, S> generator, Consumer disposeState) { ObjectHelper.requireNonNull(initialState, "initialState is null"); - ObjectHelper.requireNonNull(generator, "generator is null"); + ObjectHelper.requireNonNull(generator, "generator is null"); ObjectHelper.requireNonNull(disposeState, "disposeState is null"); return RxJavaPlugins.onAssembly(new ObservableGenerate(initialState, generator, disposeState)); } @@ -2199,6 +2236,7 @@ public static Observable interval(long initialDelay, long period, TimeUnit * @since 1.0.12 */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.CUSTOM) public static Observable interval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) { ObjectHelper.requireNonNull(unit, "unit is null"); @@ -2295,6 +2333,7 @@ public static Observable intervalRange(long start, long count, long initia * @return the new Observable instance */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.CUSTOM) public static Observable intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit, Scheduler scheduler) { if (count < 0) { @@ -2344,9 +2383,10 @@ public static Observable intervalRange(long start, long count, long initia * @see #fromIterable(Iterable) */ @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable just(T item) { - ObjectHelper.requireNonNull(item, "The item is null"); + ObjectHelper.requireNonNull(item, "item is null"); return RxJavaPlugins.onAssembly(new ObservableJust(item)); } @@ -2370,10 +2410,11 @@ public static Observable just(T item) { */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable just(T item1, T item2) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); return fromArray(item1, item2); } @@ -2400,11 +2441,12 @@ public static Observable just(T item1, T item2) { */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable just(T item1, T item2, T item3) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); - ObjectHelper.requireNonNull(item3, "The third item is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); + ObjectHelper.requireNonNull(item3, "item3 is null"); return fromArray(item1, item2, item3); } @@ -2433,12 +2475,13 @@ public static Observable just(T item1, T item2, T item3) { */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable just(T item1, T item2, T item3, T item4) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); - ObjectHelper.requireNonNull(item3, "The third item is null"); - ObjectHelper.requireNonNull(item4, "The fourth item is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); + ObjectHelper.requireNonNull(item3, "item3 is null"); + ObjectHelper.requireNonNull(item4, "item4 is null"); return fromArray(item1, item2, item3, item4); } @@ -2469,13 +2512,14 @@ public static Observable just(T item1, T item2, T item3, T item4) { */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable just(T item1, T item2, T item3, T item4, T item5) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); - ObjectHelper.requireNonNull(item3, "The third item is null"); - ObjectHelper.requireNonNull(item4, "The fourth item is null"); - ObjectHelper.requireNonNull(item5, "The fifth item is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); + ObjectHelper.requireNonNull(item3, "item3 is null"); + ObjectHelper.requireNonNull(item4, "item4 is null"); + ObjectHelper.requireNonNull(item5, "item5 is null"); return fromArray(item1, item2, item3, item4, item5); } @@ -2508,14 +2552,15 @@ public static Observable just(T item1, T item2, T item3, T item4, T item5 */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable just(T item1, T item2, T item3, T item4, T item5, T item6) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); - ObjectHelper.requireNonNull(item3, "The third item is null"); - ObjectHelper.requireNonNull(item4, "The fourth item is null"); - ObjectHelper.requireNonNull(item5, "The fifth item is null"); - ObjectHelper.requireNonNull(item6, "The sixth item is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); + ObjectHelper.requireNonNull(item3, "item3 is null"); + ObjectHelper.requireNonNull(item4, "item4 is null"); + ObjectHelper.requireNonNull(item5, "item5 is null"); + ObjectHelper.requireNonNull(item6, "item6 is null"); return fromArray(item1, item2, item3, item4, item5, item6); } @@ -2550,15 +2595,16 @@ public static Observable just(T item1, T item2, T item3, T item4, T item5 */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable just(T item1, T item2, T item3, T item4, T item5, T item6, T item7) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); - ObjectHelper.requireNonNull(item3, "The third item is null"); - ObjectHelper.requireNonNull(item4, "The fourth item is null"); - ObjectHelper.requireNonNull(item5, "The fifth item is null"); - ObjectHelper.requireNonNull(item6, "The sixth item is null"); - ObjectHelper.requireNonNull(item7, "The seventh item is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); + ObjectHelper.requireNonNull(item3, "item3 is null"); + ObjectHelper.requireNonNull(item4, "item4 is null"); + ObjectHelper.requireNonNull(item5, "item5 is null"); + ObjectHelper.requireNonNull(item6, "item6 is null"); + ObjectHelper.requireNonNull(item7, "item7 is null"); return fromArray(item1, item2, item3, item4, item5, item6, item7); } @@ -2595,16 +2641,17 @@ public static Observable just(T item1, T item2, T item3, T item4, T item5 */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); - ObjectHelper.requireNonNull(item3, "The third item is null"); - ObjectHelper.requireNonNull(item4, "The fourth item is null"); - ObjectHelper.requireNonNull(item5, "The fifth item is null"); - ObjectHelper.requireNonNull(item6, "The sixth item is null"); - ObjectHelper.requireNonNull(item7, "The seventh item is null"); - ObjectHelper.requireNonNull(item8, "The eighth item is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); + ObjectHelper.requireNonNull(item3, "item3 is null"); + ObjectHelper.requireNonNull(item4, "item4 is null"); + ObjectHelper.requireNonNull(item5, "item5 is null"); + ObjectHelper.requireNonNull(item6, "item6 is null"); + ObjectHelper.requireNonNull(item7, "item7 is null"); + ObjectHelper.requireNonNull(item8, "item8 is null"); return fromArray(item1, item2, item3, item4, item5, item6, item7, item8); } @@ -2643,17 +2690,18 @@ public static Observable just(T item1, T item2, T item3, T item4, T item5 */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); - ObjectHelper.requireNonNull(item3, "The third item is null"); - ObjectHelper.requireNonNull(item4, "The fourth item is null"); - ObjectHelper.requireNonNull(item5, "The fifth item is null"); - ObjectHelper.requireNonNull(item6, "The sixth item is null"); - ObjectHelper.requireNonNull(item7, "The seventh item is null"); - ObjectHelper.requireNonNull(item8, "The eighth item is null"); - ObjectHelper.requireNonNull(item9, "The ninth item is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); + ObjectHelper.requireNonNull(item3, "item3 is null"); + ObjectHelper.requireNonNull(item4, "item4 is null"); + ObjectHelper.requireNonNull(item5, "item5 is null"); + ObjectHelper.requireNonNull(item6, "item6 is null"); + ObjectHelper.requireNonNull(item7, "item7 is null"); + ObjectHelper.requireNonNull(item8, "item8 is null"); + ObjectHelper.requireNonNull(item9, "item9 is null"); return fromArray(item1, item2, item3, item4, item5, item6, item7, item8, item9); } @@ -2694,18 +2742,19 @@ public static Observable just(T item1, T item2, T item3, T item4, T item5 */ @SuppressWarnings("unchecked") @CheckReturnValue + @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static Observable just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9, T item10) { - ObjectHelper.requireNonNull(item1, "The first item is null"); - ObjectHelper.requireNonNull(item2, "The second item is null"); - ObjectHelper.requireNonNull(item3, "The third item is null"); - ObjectHelper.requireNonNull(item4, "The fourth item is null"); - ObjectHelper.requireNonNull(item5, "The fifth item is null"); - ObjectHelper.requireNonNull(item6, "The sixth item is null"); - ObjectHelper.requireNonNull(item7, "The seventh item is null"); - ObjectHelper.requireNonNull(item8, "The eighth item is null"); - ObjectHelper.requireNonNull(item9, "The ninth item is null"); - ObjectHelper.requireNonNull(item10, "The tenth item is null"); + ObjectHelper.requireNonNull(item1, "item1 is null"); + ObjectHelper.requireNonNull(item2, "item2 is null"); + ObjectHelper.requireNonNull(item3, "item3 is null"); + ObjectHelper.requireNonNull(item4, "item4 is null"); + ObjectHelper.requireNonNull(item5, "item5 is null"); + ObjectHelper.requireNonNull(item6, "item6 is null"); + ObjectHelper.requireNonNull(item7, "item7 is null"); + ObjectHelper.requireNonNull(item8, "item8 is null"); + ObjectHelper.requireNonNull(item9, "item9 is null"); + ObjectHelper.requireNonNull(item10, "item10 is null"); return fromArray(item1, item2, item3, item4, item5, item6, item7, item8, item9, item10); } @@ -3933,7 +3982,7 @@ public static Observable timer(long delay, TimeUnit unit, Scheduler schedu /** * Create an Observable by wrapping an ObservableSource which has to be implemented according - * to the Reactive-Streams-based Observable specification by handling + * to the Reactive Streams based Observable specification by handling * disposal correctly; no safeguards are provided by the Observable itself. *
*
Scheduler:
@@ -3946,7 +3995,6 @@ public static Observable timer(long delay, TimeUnit unit, Scheduler schedu @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static Observable unsafeCreate(ObservableSource onSubscribe) { - ObjectHelper.requireNonNull(onSubscribe, "source is null"); ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null"); if (onSubscribe instanceof Observable) { throw new IllegalArgumentException("unsafeCreate(Observable) should be upgraded"); @@ -7235,7 +7283,6 @@ public final Single contains(final Object element) { * @return a Single that emits a single item: the number of items emitted by the source ObservableSource as a * 64-bit Long item * @see ReactiveX operators documentation: Count - * @see #count() */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -7248,6 +7295,14 @@ public final Single count() { * source ObservableSource that are followed by another item within a computed debounce duration. *

* + *

+ * The delivery of the item happens on the thread of the first {@code onNext} or {@code onComplete} + * signal of the generated {@code ObservableSource} sequence, + * which if takes too long, a newer item may arrive from the upstream, causing the + * generated sequence to get disposed, which may also interrupt any downstream blocking operation + * (yielding an {@code InterruptedException}). It is recommended processing items + * that may take long time to be moved to another thread via {@link #observeOn} applied after + * {@code debounce} itself. *

*
Scheduler:
*
This version of {@code debounce} does not operate by default on a particular {@link Scheduler}.
@@ -7277,6 +7332,13 @@ public final Observable debounce(Function * + *

+ * Delivery of the item after the grace period happens on the {@code computation} {@code Scheduler}'s + * {@code Worker} which if takes too long, a newer item may arrive from the upstream, causing the + * {@code Worker}'s task to get disposed, which may also interrupt any downstream blocking operation + * (yielding an {@code InterruptedException}). It is recommended processing items + * that may take long time to be moved to another thread via {@link #observeOn} applied after + * {@code debounce} itself. *

*
Scheduler:
*
{@code debounce} operates by default on the {@code computation} {@link Scheduler}.
@@ -7308,6 +7370,13 @@ public final Observable debounce(long timeout, TimeUnit unit) { * will be emitted by the resulting ObservableSource. *

* + *

+ * Delivery of the item after the grace period happens on the given {@code Scheduler}'s + * {@code Worker} which if takes too long, a newer item may arrive from the upstream, causing the + * {@code Worker}'s task to get disposed, which may also interrupt any downstream blocking operation + * (yielding an {@code InterruptedException}). It is recommended processing items + * that may take long time to be moved to another thread via {@link #observeOn} applied after + * {@code debounce} itself. *

*
Scheduler:
*
You specify which {@link Scheduler} this operator will use.
@@ -7830,7 +7899,7 @@ public final Observable distinct(Function keySelector, Call * {@code CharSequence}s or {@code List}s where the objects will actually have the same * references when they are modified and {@code distinctUntilChanged} will evaluate subsequent items as same. * To avoid such situation, it is recommended that mutable data is converted to an immutable one, - * for example using `map(CharSequence::toString)` or `map(list -> Collections.unmodifiableList(new ArrayList<>(list)))`. + * for example using {@code map(CharSequence::toString)} or {@code map(list -> Collections.unmodifiableList(new ArrayList<>(list)))}. *
*
Scheduler:
*
{@code distinctUntilChanged} does not operate by default on a particular {@link Scheduler}.
@@ -7869,7 +7938,7 @@ public final Observable distinctUntilChanged() { * {@code CharSequence}s or {@code List}s where the objects will actually have the same * references when they are modified and {@code distinctUntilChanged} will evaluate subsequent items as same. * To avoid such situation, it is recommended that mutable data is converted to an immutable one, - * for example using `map(CharSequence::toString)` or `map(list -> Collections.unmodifiableList(new ArrayList<>(list)))`. + * for example using {@code map(CharSequence::toString)} or {@code map(list -> Collections.unmodifiableList(new ArrayList<>(list)))}. *
*
Scheduler:
*
{@code distinctUntilChanged} does not operate by default on a particular {@link Scheduler}.
@@ -7904,7 +7973,7 @@ public final Observable distinctUntilChanged(Function keySe * {@code CharSequence}s or {@code List}s where the objects will actually have the same * references when they are modified and {@code distinctUntilChanged} will evaluate subsequent items as same. * To avoid such situation, it is recommended that mutable data is converted to an immutable one, - * for example using `map(CharSequence::toString)` or `map(list -> Collections.unmodifiableList(new ArrayList<>(list)))`. + * for example using {@code map(CharSequence::toString)} or {@code map(list -> Collections.unmodifiableList(new ArrayList<>(list)))}. *
*
Scheduler:
*
{@code distinctUntilChanged} does not operate by default on a particular {@link Scheduler}.
@@ -8086,7 +8155,7 @@ private Observable doOnEach(Consumer onNext, Consumer doOnEach(final Consumer> onNotification) { - ObjectHelper.requireNonNull(onNotification, "consumer is null"); + ObjectHelper.requireNonNull(onNotification, "onNotification is null"); return doOnEach( Functions.notificationOnNext(onNotification), Functions.notificationOnError(onNotification), @@ -9507,7 +9576,7 @@ public final Maybe lastElement() { * * @param defaultItem * the default item to emit if the source ObservableSource is empty - * @return an Observable that emits only the last item emitted by the source ObservableSource, or a default item + * @return a Single that emits only the last item emitted by the source ObservableSource, or a default item * if the source ObservableSource is empty * @see ReactiveX operators documentation: Last */ @@ -9556,7 +9625,7 @@ public final Single lastOrError() { * Example: * 

      * // Step 1: Create the consumer type that will be returned by the ObservableOperator.apply():
-     * 
+     *
      * public final class CustomObserver<T> implements Observer<T>, Disposable {
      *
      *     // The downstream's Observer that will receive the onXXX events
@@ -9683,7 +9752,7 @@ public final Single lastOrError() {
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.NONE)
     public final  Observable lift(ObservableOperator lifter) {
-        ObjectHelper.requireNonNull(lifter, "onLift is null");
+        ObjectHelper.requireNonNull(lifter, "lifter is null");
         return RxJavaPlugins.onAssembly(new ObservableLift(this, lifter));
     }
 
@@ -9832,6 +9901,11 @@ public final Observable mergeWith(@NonNull CompletableSource other) {
      * asynchronous. If strict event ordering is required, consider using the {@link #observeOn(Scheduler, boolean)} overload.
      * 

      * 
+     * 

+     * This operator keeps emitting as many signals as it can on the given Scheduler's Worker thread,
+     * which may result in a longer than expected occupation of this thread. In other terms,
+     * it does not allow per-signal fairness in case the worker runs on a shared underlying thread.
+     * If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead.
      * 

      *  
Scheduler:

      *  
You specify which {@link Scheduler} this operator will use.

@@ -9848,6 +9922,7 @@ public final Observable mergeWith(@NonNull CompletableSource other) {
      * @see #subscribeOn
      * @see #observeOn(Scheduler, boolean)
      * @see #observeOn(Scheduler, boolean, int)
+     * @see #delay(long, TimeUnit, Scheduler)
      */
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.CUSTOM)
@@ -9860,6 +9935,11 @@ public final Observable observeOn(Scheduler scheduler) {
      * asynchronously with an unbounded buffer with {@link Flowable#bufferSize()} "island size" and optionally delays onError notifications.
      * 

      * 
+     * 

+     * This operator keeps emitting as many signals as it can on the given Scheduler's Worker thread,
+     * which may result in a longer than expected occupation of this thread. In other terms,
+     * it does not allow per-signal fairness in case the worker runs on a shared underlying thread.
+     * If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead.
      * 

      *  
Scheduler:

      *  
You specify which {@link Scheduler} this operator will use.

@@ -9880,6 +9960,7 @@ public final Observable observeOn(Scheduler scheduler) {
      * @see #subscribeOn
      * @see #observeOn(Scheduler)
      * @see #observeOn(Scheduler, boolean, int)
+     * @see #delay(long, TimeUnit, Scheduler, boolean)
      */
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.CUSTOM)
@@ -9892,6 +9973,11 @@ public final Observable observeOn(Scheduler scheduler, boolean delayError) {
      * asynchronously with an unbounded buffer of configurable "island size" and optionally delays onError notifications.
      * 

      * 
+     * 

+     * This operator keeps emitting as many signals as it can on the given Scheduler's Worker thread,
+     * which may result in a longer than expected occupation of this thread. In other terms,
+     * it does not allow per-signal fairness in case the worker runs on a shared underlying thread.
+     * If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead.
      * 

      *  
Scheduler:

      *  
You specify which {@link Scheduler} this operator will use.

@@ -9913,6 +9999,7 @@ public final Observable observeOn(Scheduler scheduler, boolean delayError) {
      * @see #subscribeOn
      * @see #observeOn(Scheduler)
      * @see #observeOn(Scheduler, boolean)
+     * @see #delay(long, TimeUnit, Scheduler, boolean)
      */
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.CUSTOM)
@@ -11005,7 +11092,7 @@ public final Observable retry(BiPredicate
      * 

      *
      * @param times
-     *            number of retry attempts before failing
+     *            the number of times to resubscribe if the current Observable fails
      * @return the source ObservableSource modified with retry logic
      * @see ReactiveX operators documentation: Retry
      */
@@ -11023,7 +11110,7 @@ public final Observable retry(long times) {
      *  
Scheduler:

      *  
{@code retry} does not operate by default on a particular {@link Scheduler}.

      * 

-     * @param times the number of times to repeat
+     * @param times the number of times to resubscribe if the current Observable fails
      * @param predicate the predicate called with the failure Throwable and should return true to trigger a retry.
      * @return the new Observable instance
      */
@@ -11159,7 +11246,7 @@ public final Observable retryWhen(
      * Subscribes to the current Observable and wraps the given Observer into a SafeObserver
      * (if not already a SafeObserver) that
      * deals with exceptions thrown by a misbehaving Observer (that doesn't follow the
-     * Reactive-Streams specification).
+     * Reactive Streams specification).
      * 

      *  
Scheduler:

      *  
{@code safeSubscribe} does not operate by default on a particular {@link Scheduler}.

@@ -11169,7 +11256,7 @@ public final Observable retryWhen(
      */
     @SchedulerSupport(SchedulerSupport.NONE)
     public final void safeSubscribe(Observer observer) {
-        ObjectHelper.requireNonNull(observer, "s is null");
+        ObjectHelper.requireNonNull(observer, "observer is null");
         if (observer instanceof SafeObserver) {
             subscribe(observer);
         } else {
@@ -11428,7 +11515,7 @@ public final Observable scan(BiFunction accumulator) {
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.NONE)
     public final  Observable scan(final R initialValue, BiFunction accumulator) {
-        ObjectHelper.requireNonNull(initialValue, "seed is null");
+        ObjectHelper.requireNonNull(initialValue, "initialValue is null");
         return scanWith(Functions.justCallable(initialValue), accumulator);
     }
 
@@ -12317,6 +12404,7 @@ public final Observable switchIfEmpty(ObservableSource other) {
      *            ObservableSource
      * @return an Observable that emits the items emitted by the ObservableSource returned from applying {@code func} to the most recently emitted item emitted by the source ObservableSource
      * @see ReactiveX operators documentation: FlatMap
+     * @see #switchMapDelayError(Function)
      */
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.NONE)
@@ -12346,6 +12434,7 @@ public final  Observable switchMap(FunctionReactiveX operators documentation: FlatMap
+     * @see #switchMapDelayError(Function, int)
      */
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.NONE)
@@ -12436,7 +12525,7 @@ public final Completable switchMapCompletable(@NonNull Function Observable switchMapMaybeDelayError(@NonNull FunctionReactiveX operators documentation: FlatMap
+     * @see #switchMapSingleDelayError(Function)
      * @since 2.2
      */
     @CheckReturnValue
@@ -12559,6 +12649,7 @@ public final  Observable switchMapSingle(@NonNull FunctionReactiveX operators documentation: FlatMap
+     * @see #switchMapSingle(Function)
      * @since 2.2
      */
     @CheckReturnValue
@@ -12590,6 +12681,7 @@ public final  Observable switchMapSingleDelayError(@NonNull FunctionReactiveX operators documentation: FlatMap
+     * @see #switchMap(Function)
      * @since 2.0
      */
     @CheckReturnValue
@@ -12621,6 +12713,7 @@ public final  Observable switchMapDelayError(FunctionReactiveX operators documentation: FlatMap
+     * @see #switchMap(Function, int)
      * @since 2.0
      */
     @CheckReturnValue
@@ -12746,10 +12839,10 @@ public final Observable take(long time, TimeUnit unit, Scheduler scheduler) {
     public final Observable takeLast(int count) {
         if (count < 0) {
             throw new IndexOutOfBoundsException("count >= 0 required but it was " + count);
-        } else
+        }
         if (count == 0) {
             return RxJavaPlugins.onAssembly(new ObservableIgnoreElements(this));
-        } else
+        }
         if (count == 1) {
             return RxJavaPlugins.onAssembly(new ObservableTakeLastOne(this));
         }
@@ -13051,7 +13144,7 @@ public final  Observable takeUntil(ObservableSource other) {
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Observable takeUntil(Predicate stopPredicate) {
-        ObjectHelper.requireNonNull(stopPredicate, "predicate is null");
+        ObjectHelper.requireNonNull(stopPredicate, "stopPredicate is null");
         return RxJavaPlugins.onAssembly(new ObservableTakeUntilPredicate(this, stopPredicate));
     }
 
@@ -13568,7 +13661,8 @@ public final Observable timeout(long timeout, TimeUnit timeUnit) {
     /**
      * Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted
      * item. If the next item isn't emitted within the specified timeout duration starting from its predecessor,
-     * the resulting ObservableSource begins instead to mirror a fallback ObservableSource.
+     * the source ObservableSource is disposed and resulting ObservableSource begins instead
+     * to mirror a fallback ObservableSource.
      * 

      * 
      * 

@@ -13595,7 +13689,8 @@ public final Observable timeout(long timeout, TimeUnit timeUnit, ObservableSo
     /**
      * Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted
      * item using a specified Scheduler. If the next item isn't emitted within the specified timeout duration
-     * starting from its predecessor, the resulting ObservableSource begins instead to mirror a fallback ObservableSource.
+     * starting from its predecessor, the source ObservableSource is disposed and resulting ObservableSource
+     * begins instead to mirror a fallback ObservableSource.
      * 

      * 
      * 

diff --git a/src/main/java/io/reactivex/Scheduler.java b/src/main/java/io/reactivex/Scheduler.java
index 2e99e288f1..882fdaa060 100644
--- a/src/main/java/io/reactivex/Scheduler.java
+++ b/src/main/java/io/reactivex/Scheduler.java
@@ -61,8 +61,9 @@
  * interface which can grant access to the original or hooked {@code Runnable}, thus, a repeated {@code RxJavaPlugins.onSchedule}
  * can detect the earlier hook and not apply a new one over again.
  * 

- * The default implementation of {@link #now(TimeUnit)} and {@link Worker#now(TimeUnit)} methods to return current
- * {@link System#currentTimeMillis()} value in the desired time unit. Custom {@code Scheduler} implementations can override this
+ * The default implementation of {@link #now(TimeUnit)} and {@link Worker#now(TimeUnit)} methods to return current {@link System#currentTimeMillis()}
+ * value in the desired time unit, unless {@code rx2.scheduler.use-nanotime} (boolean) is set. When the property is set to
+ * {@code true}, the method uses {@link System#nanoTime()} as its basis instead. Custom {@code Scheduler} implementations can override this
  * to provide specialized time accounting (such as virtual time to be advanced programmatically).
  * Note that operators requiring a {@code Scheduler} may rely on either of the {@code now()} calls provided by
  * {@code Scheduler} or {@code Worker} respectively, therefore, it is recommended they represent a logically
@@ -89,6 +90,34 @@
  * All methods on the {@code Scheduler} and {@code Worker} classes should be thread safe.
  */
 public abstract class Scheduler {
+    /**
+     * Value representing whether to use {@link System#nanoTime()}, or default as clock for {@link #now(TimeUnit)}
+     * and {@link Scheduler.Worker#now(TimeUnit)}
+     * 

+     * Associated system parameter:
+     * 
    
+     *   
  • {@code rx2.scheduler.use-nanotime}, boolean, default {@code false}
+     * 

+     */
+    static boolean IS_DRIFT_USE_NANOTIME = Boolean.getBoolean("rx2.scheduler.use-nanotime");
+
+    /**
+     * Returns the current clock time depending on state of {@link Scheduler#IS_DRIFT_USE_NANOTIME} in given {@code unit}
+     * 

+     * By default {@link System#currentTimeMillis()} will be used as the clock. When the property is set
+     * {@link System#nanoTime()} will be used.
+     * 

+     * @param unit the time unit
+     * @return the 'current time' in given unit
+     * @throws NullPointerException if {@code unit} is {@code null}
+     */
+    static long computeNow(TimeUnit unit) {
+      if(!IS_DRIFT_USE_NANOTIME) {
+        return unit.convert(System.currentTimeMillis(), TimeUnit.MILLISECONDS);
+      }
+      return unit.convert(System.nanoTime(), TimeUnit.NANOSECONDS);
+    }
+
     /**
      * The tolerance for a clock drift in nanoseconds where the periodic scheduler will rebase.
      * 

@@ -131,7 +160,7 @@ public static long clockDriftTolerance() {
      * @since 2.0
      */
     public long now(@NonNull TimeUnit unit) {
-        return unit.convert(System.currentTimeMillis(), TimeUnit.MILLISECONDS);
+        return computeNow(unit);
     }
 
     /**
@@ -332,8 +361,9 @@ public  S when(@NonNull Function
-     * The default implementation of the {@link #now(TimeUnit)} method returns current
-     * {@link System#currentTimeMillis()} value in the desired time unit. Custom {@code Worker} implementations can override this
+     * The default implementation of the {@link #now(TimeUnit)} method returns current {@link System#currentTimeMillis()}
+     * value in the desired time unit, unless {@code rx2.scheduler.use-nanotime} (boolean) is set. When the property is set to
+     * {@code true}, the method uses {@link System#nanoTime()} as its basis instead. Custom {@code Worker} implementations can override this
      * to provide specialized time accounting (such as virtual time to be advanced programmatically).
      * Note that operators requiring a scheduler may rely on either of the {@code now()} calls provided by
      * {@code Scheduler} or {@code Worker} respectively, therefore, it is recommended they represent a logically
@@ -448,7 +478,7 @@ public Disposable schedulePeriodically(@NonNull Runnable run, final long initial
          * @since 2.0
          */
         public long now(@NonNull TimeUnit unit) {
-            return unit.convert(System.currentTimeMillis(), TimeUnit.MILLISECONDS);
+            return computeNow(unit);
         }
 
         /**
diff --git a/src/main/java/io/reactivex/Single.java b/src/main/java/io/reactivex/Single.java
index 168c9c216a..15ef6b6c14 100644
--- a/src/main/java/io/reactivex/Single.java
+++ b/src/main/java/io/reactivex/Single.java
@@ -129,6 +129,7 @@ public abstract class Single implements SingleSource {
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public static  Single amb(final Iterable> sources) {
         ObjectHelper.requireNonNull(sources, "sources is null");
@@ -180,6 +181,7 @@ public static  Single ambArray(final SingleSource... sources)
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     @BackpressureSupport(BackpressureKind.FULL)
     public static  Flowable concat(Iterable> sources) {
@@ -201,6 +203,7 @@ public static  Flowable concat(Iterable Observable concat(ObservableSource> sources) {
@@ -226,6 +229,7 @@ public static  Observable concat(ObservableSource Flowable concat(Publisher> sources) {
@@ -251,6 +255,7 @@ public static  Flowable concat(Publisher Flowable concat(PublisherReactiveX operators documentation: Concat
      */
     @CheckReturnValue
+    @NonNull
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings("unchecked")
@@ -313,6 +319,7 @@ public static  Flowable concat(
      * @see ReactiveX operators documentation: Concat
      */
     @CheckReturnValue
+    @NonNull
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings("unchecked")
@@ -350,6 +357,7 @@ public static  Flowable concat(
      * @see ReactiveX operators documentation: Concat
      */
     @CheckReturnValue
+    @NonNull
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings("unchecked")
@@ -381,6 +389,7 @@ public static  Flowable concat(
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings({ "unchecked", "rawtypes" })
@@ -391,6 +400,8 @@ public static  Flowable concatArray(SingleSource... sources)
     /**
      * Concatenates a sequence of SingleSource eagerly into a single stream of values.
      * 

+     * 
+     * 

      * Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the
      * source SingleSources. The operator buffers the value emitted by these SingleSources and then drains them
      * in order, each one after the previous one completes.
@@ -406,6 +417,7 @@ public static  Flowable concatArray(SingleSource... sources)
      */
     @BackpressureSupport(BackpressureKind.FULL)
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public static  Flowable concatArrayEager(SingleSource... sources) {
         return Flowable.fromArray(sources).concatMapEager(SingleInternalHelper.toFlowable());
@@ -433,6 +445,7 @@ public static  Flowable concatArrayEager(SingleSource... sour
      */
     @BackpressureSupport(BackpressureKind.FULL)
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public static  Flowable concatEager(Publisher> sources) {
         return Flowable.fromPublisher(sources).concatMapEager(SingleInternalHelper.toFlowable());
@@ -458,13 +471,14 @@ public static  Flowable concatEager(Publisher Flowable concatEager(Iterable> sources) {
         return Flowable.fromIterable(sources).concatMapEager(SingleInternalHelper.toFlowable());
     }
 
     /**
-     * Provides an API (via a cold Completable) that bridges the reactive world with the callback-style world.
+     * Provides an API (via a cold Single) that bridges the reactive world with the callback-style world.
      * 

      * 
      * 

@@ -500,6 +514,7 @@ public static  Flowable concatEager(Iterable Single create(SingleOnSubscribe source) {
         ObjectHelper.requireNonNull(source, "source is null");
@@ -521,6 +536,7 @@ public static  Single create(SingleOnSubscribe source) {
      * @return the new Single instance
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public static  Single defer(final Callable> singleSupplier) {
         ObjectHelper.requireNonNull(singleSupplier, "singleSupplier is null");
@@ -541,6 +557,7 @@ public static  Single defer(final Callable Single error(final Callable errorSupplier) {
         ObjectHelper.requireNonNull(errorSupplier, "errorSupplier is null");
@@ -566,9 +583,10 @@ public static  Single error(final Callable errorSuppl
      * @see ReactiveX operators documentation: Throw
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public static  Single error(final Throwable exception) {
-        ObjectHelper.requireNonNull(exception, "error is null");
+        ObjectHelper.requireNonNull(exception, "exception is null");
         return error(Functions.justCallable(exception));
     }
 
@@ -599,6 +617,7 @@ public static  Single error(final Throwable exception) {
      * @return a {@link Single} whose {@link SingleObserver}s' subscriptions trigger an invocation of the given function.
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public static  Single fromCallable(final Callable callable) {
         ObjectHelper.requireNonNull(callable, "callable is null");
@@ -738,7 +757,7 @@ public static  Single fromFuture(Future future, Scheduler sch
      * the source has more than one element, an IndexOutOfBoundsException is signalled.
      * 

      * The {@link Publisher} must follow the
-     * Reactive-Streams specification.
+     * Reactive Streams specification.
      * Violating the specification may result in undefined behavior.
      * 

      * If possible, use {@link #create(SingleOnSubscribe)} to create a
@@ -763,6 +782,7 @@ public static  Single fromFuture(Future future, Scheduler sch
      */
     @BackpressureSupport(BackpressureKind.UNBOUNDED_IN)
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public static  Single fromPublisher(final Publisher publisher) {
         ObjectHelper.requireNonNull(publisher, "publisher is null");
@@ -786,6 +806,7 @@ public static  Single fromPublisher(final Publisher publisher
      * @return the new Single instance
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public static  Single fromObservable(ObservableSource observableSource) {
         ObjectHelper.requireNonNull(observableSource, "observableSource is null");
@@ -813,8 +834,9 @@ public static  Single fromObservable(ObservableSource observa
      */
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.NONE)
+    @NonNull
     public static  Single just(final T item) {
-        ObjectHelper.requireNonNull(item, "value is null");
+        ObjectHelper.requireNonNull(item, "item is null");
         return RxJavaPlugins.onAssembly(new SingleJust(item));
     }
 
@@ -849,6 +871,7 @@ public static  Single just(final T item) {
      * @see #mergeDelayError(Iterable)
      */
     @CheckReturnValue
+    @NonNull
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.NONE)
     public static  Flowable merge(Iterable> sources) {
@@ -886,6 +909,7 @@ public static  Flowable merge(Iterable
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings({ "unchecked", "rawtypes" })
@@ -917,6 +941,7 @@ public static  Flowable merge(PublisherReactiveX operators documentation: Merge
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public static  Single merge(SingleSource> source) {
@@ -961,6 +986,7 @@ public static  Single merge(SingleSource Flowable merge(
      * @see #mergeDelayError(SingleSource, SingleSource, SingleSource)
      */
     @CheckReturnValue
+    @NonNull
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings("unchecked")
@@ -1065,6 +1092,7 @@ public static  Flowable merge(
      * @see #mergeDelayError(SingleSource, SingleSource, SingleSource, SingleSource)
      */
     @CheckReturnValue
+    @NonNull
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings("unchecked")
@@ -1082,6 +1110,8 @@ public static  Flowable merge(
     /**
      * Merges an Iterable sequence of SingleSource instances into a single Flowable sequence,
      * running all SingleSources at once and delaying any error(s) until all sources succeed or fail.
+     * 

+     * 
      * 

      *  
Backpressure:

      *  
The returned {@code Flowable} honors the backpressure of the downstream consumer.

@@ -1096,6 +1126,7 @@ public static  Flowable merge(
      * @since 2.2
      */
     @CheckReturnValue
+    @NonNull
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.NONE)
     public static  Flowable mergeDelayError(Iterable> sources) {
@@ -1105,6 +1136,8 @@ public static  Flowable mergeDelayError(Iterable
+     * 
      * 

      *  
Backpressure:

      *  
The returned {@code Flowable} honors the backpressure of the downstream consumer.

@@ -1119,6 +1152,7 @@ public static  Flowable mergeDelayError(Iterable Flowable mergeDelayError(Publisher
-     * 
+     * 
      * 

      * You can combine items emitted by multiple Singles so that they appear as a single Flowable, by
      * using the {@code mergeDelayError} method.
@@ -1153,6 +1187,7 @@ public static  Flowable mergeDelayError(Publisher Flowable mergeDelayError(
      * Flattens three Singles into a single Flowable, without any transformation, delaying
      * any error(s) until all sources succeed or fail.
      * 

-     * 
+     * 
      * 

      * You can combine items emitted by multiple Singles so that they appear as a single Flowable, by using
      * the {@code mergeDelayError} method.
@@ -1192,6 +1227,7 @@ public static  Flowable mergeDelayError(
      * @since 2.2
      */
     @CheckReturnValue
+    @NonNull
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings("unchecked")
@@ -1209,7 +1245,7 @@ public static  Flowable mergeDelayError(
      * Flattens four Singles into a single Flowable, without any transformation, delaying
      * any error(s) until all sources succeed or fail.
      * 

-     * 
+     * 
      * 

      * You can combine items emitted by multiple Singles so that they appear as a single Flowable, by using
      * the {@code mergeDelayError} method.
@@ -1235,6 +1271,7 @@ public static  Flowable mergeDelayError(
      * @since 2.2
      */
     @CheckReturnValue
+    @NonNull
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings("unchecked")
@@ -1305,6 +1342,7 @@ public static Single timer(long delay, TimeUnit unit) {
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.CUSTOM)
     public static Single timer(final long delay, final TimeUnit unit, final Scheduler scheduler) {
         ObjectHelper.requireNonNull(unit, "unit is null");
@@ -1327,6 +1365,7 @@ public static Single timer(final long delay, final TimeUnit unit, final Sc
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public static  Single equals(final SingleSource first, final SingleSource second) { // NOPMD
         ObjectHelper.requireNonNull(first, "first is null");
@@ -1337,6 +1376,8 @@ public static  Single equals(final SingleSource first,
     /**
      * Advanced use only: creates a Single instance without
      * any safeguards by using a callback that is called with a SingleObserver.
+     * 

+     * 
      * 

      * 
Scheduler:

      * 
{@code unsafeCreate} does not operate by default on a particular {@link Scheduler}.

@@ -1350,6 +1391,7 @@ public static  Single equals(final SingleSource first,
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public static  Single unsafeCreate(SingleSource onSubscribe) {
         ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null");
@@ -1362,6 +1404,8 @@ public static  Single unsafeCreate(SingleSource onSubscribe) {
     /**
      * Allows using and disposing a resource while running a SingleSource instance generated from
      * that resource (similar to a try-with-resources).
+     * 

+     * 
      * 

      * 
Scheduler:

      * 
{@code using} does not operate by default on a particular {@link Scheduler}.

@@ -1389,6 +1433,8 @@ public static  Single using(Callable resourceSupplier,
     /**
      * Allows using and disposing a resource while running a SingleSource instance generated from
      * that resource (similar to a try-with-resources).
+     * 

+     * 
      * 

      * 
Scheduler:

      * 
{@code using} does not operate by default on a particular {@link Scheduler}.

@@ -1409,6 +1455,7 @@ public static  Single using(Callable resourceSupplier,
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public static  Single using(
             final Callable resourceSupplier,
@@ -1425,6 +1472,8 @@ public static  Single using(
     /**
      * Wraps a SingleSource instance into a new Single instance if not already a Single
      * instance.
+     * 

+     * 
      * 

      * 
Scheduler:

      * 
{@code wrap} does not operate by default on a particular {@link Scheduler}.

@@ -1434,6 +1483,7 @@ public static  Single using(
      * @return the Single wrapper or the source cast to Single (if possible)
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public static  Single wrap(SingleSource source) {
         ObjectHelper.requireNonNull(source, "source is null");
@@ -1473,6 +1523,7 @@ public static  Single wrap(SingleSource source) {
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public static  Single zip(final Iterable> sources, Function zipper) {
         ObjectHelper.requireNonNull(zipper, "zipper is null");
@@ -1504,6 +1555,7 @@ public static  Single zip(final IterableReactiveX operators documentation: Zip
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings("unchecked")
     public static  Single zip(
@@ -1542,6 +1594,7 @@ public static  Single zip(
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings("unchecked")
     public static  Single zip(
@@ -1585,6 +1638,7 @@ public static  Single zip(
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings("unchecked")
     public static  Single zip(
@@ -1632,6 +1686,7 @@ public static  Single zip(
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings("unchecked")
     public static  Single zip(
@@ -1684,6 +1739,7 @@ public static  Single zip(
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings("unchecked")
     public static  Single zip(
@@ -1740,6 +1796,7 @@ public static  Single zip(
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings("unchecked")
     public static  Single zip(
@@ -1801,6 +1858,7 @@ public static  Single zip(
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings("unchecked")
     public static  Single zip(
@@ -1866,6 +1924,7 @@ public static  Single zip(
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings("unchecked")
     public static  Single zip(
@@ -1918,6 +1977,7 @@ public static  Single zip(
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public static  Single zipArray(Function zipper, SingleSource... sources) {
         ObjectHelper.requireNonNull(zipper, "zipper is null");
@@ -1942,6 +2002,7 @@ public static  Single zipArray(Function
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     @SuppressWarnings("unchecked")
     public final Single ambWith(SingleSource other) {
@@ -2020,6 +2081,7 @@ public final  Single compose(SingleTransformer tra
     /**
      * Stores the success value or exception from the current Single and replays it to late SingleObservers.
      * 

+     * 
      * The returned Single subscribes to the current Single when the first SingleObserver subscribes.
      * 

      * 
Scheduler:

@@ -2038,6 +2100,8 @@ public final Single cache() {
     /**
      * Casts the success value of the current Single into the target type or signals a
      * ClassCastException if not compatible.
+     * 

+     * 
      * 

      * 
Scheduler:

      * 
{@code cast} does not operate by default on a particular {@link Scheduler}.

@@ -2048,6 +2112,7 @@ public final Single cache() {
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final  Single cast(final Class clazz) {
         ObjectHelper.requireNonNull(clazz, "clazz is null");
@@ -2166,6 +2231,7 @@ public final Single delay(final long time, final TimeUnit unit, final Schedul
      * @since 2.2
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.CUSTOM)
     public final Single delay(final long time, final TimeUnit unit, final Scheduler scheduler, boolean delayError) {
         ObjectHelper.requireNonNull(unit, "unit is null");
@@ -2176,6 +2242,8 @@ public final Single delay(final long time, final TimeUnit unit, final Schedul
     /**
      * Delays the actual subscription to the current Single until the given other CompletableSource
      * completes.
+     * 

+     * 
      * 
If the delaying source signals an error, that error is re-emitted and no subscription
      * to the current Single happens.
      * 

@@ -2188,6 +2256,7 @@ public final Single delay(final long time, final TimeUnit unit, final Schedul
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Single delaySubscription(CompletableSource other) {
         ObjectHelper.requireNonNull(other, "other is null");
@@ -2197,6 +2266,8 @@ public final Single delaySubscription(CompletableSource other) {
     /**
      * Delays the actual subscription to the current Single until the given other SingleSource
      * signals success.
+     * 

+     * 
      * 
If the delaying source signals an error, that error is re-emitted and no subscription
      * to the current Single happens.
      * 

@@ -2210,6 +2281,7 @@ public final Single delaySubscription(CompletableSource other) {
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final  Single delaySubscription(SingleSource other) {
         ObjectHelper.requireNonNull(other, "other is null");
@@ -2219,6 +2291,8 @@ public final  Single delaySubscription(SingleSource other) {
     /**
      * Delays the actual subscription to the current Single until the given other ObservableSource
      * signals its first value or completes.
+     * 

+     * 
      * 
If the delaying source signals an error, that error is re-emitted and no subscription
      * to the current Single happens.
      * 

@@ -2232,6 +2306,7 @@ public final  Single delaySubscription(SingleSource other) {
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final  Single delaySubscription(ObservableSource other) {
         ObjectHelper.requireNonNull(other, "other is null");
@@ -2241,6 +2316,8 @@ public final  Single delaySubscription(ObservableSource other) {
     /**
      * Delays the actual subscription to the current Single until the given other Publisher
      * signals its first value or completes.
+     * 

+     * 
      * 
If the delaying source signals an error, that error is re-emitted and no subscription
      * to the current Single happens.
      * 
The other source is consumed in an unbounded manner (requesting Long.MAX_VALUE from it).
@@ -2259,6 +2336,7 @@ public final  Single delaySubscription(ObservableSource other) {
      */
     @BackpressureSupport(BackpressureKind.FULL)
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final  Single delaySubscription(Publisher other) {
         ObjectHelper.requireNonNull(other, "other is null");
@@ -2267,6 +2345,8 @@ public final  Single delaySubscription(Publisher other) {
 
     /**
      * Delays the actual subscription to the current Single until the given time delay elapsed.
+     * 

+     * 
      * 

      * 
Scheduler:

      * 
{@code delaySubscription} does by default subscribe to the current Single
@@ -2285,6 +2365,8 @@ public final Single delaySubscription(long time, TimeUnit unit) {
 
     /**
      * Delays the actual subscription to the current Single until the given time delay elapsed.
+     * 

+     * 
      * 

      * 
Scheduler:

      * 
{@code delaySubscription} does by default subscribe to the current Single
@@ -2307,6 +2389,8 @@ public final Single delaySubscription(long time, TimeUnit unit, Scheduler sch
      * {@code onSuccess}, {@code onError} or {@code onComplete} signals as a
      * {@link Maybe} source.
      * 

+     * 
+     * 

      * The intended use of the {@code selector} function is to perform a
      * type-safe identity mapping (see example) on a source that is already of type
      * {@code Notification}. The Java language doesn't allow
@@ -2332,6 +2416,7 @@ public final Single delaySubscription(long time, TimeUnit unit, Scheduler sch
      * @see #materialize()
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     @Experimental
     public final  Maybe dematerialize(Function> selector) {
@@ -2356,9 +2441,10 @@ public final  Maybe dematerialize(Function> sel
      * @since 2.1
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Single doAfterSuccess(Consumer onAfterSuccess) {
-        ObjectHelper.requireNonNull(onAfterSuccess, "doAfterSuccess is null");
+        ObjectHelper.requireNonNull(onAfterSuccess, "onAfterSuccess is null");
         return RxJavaPlugins.onAssembly(new SingleDoAfterSuccess(this, onAfterSuccess));
     }
 
@@ -2384,6 +2470,7 @@ public final Single doAfterSuccess(Consumer onAfterSuccess) {
      * @since 2.1
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Single doAfterTerminate(Action onAfterTerminate) {
         ObjectHelper.requireNonNull(onAfterTerminate, "onAfterTerminate is null");
@@ -2410,6 +2497,7 @@ public final Single doAfterTerminate(Action onAfterTerminate) {
      * @since 2.1
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Single doFinally(Action onFinally) {
         ObjectHelper.requireNonNull(onFinally, "onFinally is null");
@@ -2431,12 +2519,40 @@ public final Single doFinally(Action onFinally) {
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Single doOnSubscribe(final Consumer onSubscribe) {
         ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null");
         return RxJavaPlugins.onAssembly(new SingleDoOnSubscribe(this, onSubscribe));
     }
 
+    /**
+     * Returns a Single instance that calls the given onTerminate callback
+     * just before this Single completes normally or with an exception.
+     * 

+     * 
+     * 

+     * This differs from {@code doAfterTerminate} in that this happens before the {@code onSuccess} or
+     * {@code onError} notification.
+     * 

+     *  
Scheduler:

+     *  
{@code doOnTerminate} does not operate by default on a particular {@link Scheduler}.

+     * 

+     * @param onTerminate the action to invoke when the consumer calls {@code onSuccess} or {@code onError}
+     * @return the new Single instance
+     * @see ReactiveX operators documentation: Do
+     * @see #doOnTerminate(Action)
+     * @since 2.2.7 - experimental
+     */
+    @Experimental
+    @CheckReturnValue
+    @NonNull
+    @SchedulerSupport(SchedulerSupport.NONE)
+    public final Single doOnTerminate(final Action onTerminate) {
+        ObjectHelper.requireNonNull(onTerminate, "onTerminate is null");
+        return RxJavaPlugins.onAssembly(new SingleDoOnTerminate(this, onTerminate));
+    }
+
     /**
      * Calls the shared consumer with the success value sent via onSuccess for each
      * SingleObserver that subscribes to the current Single.
@@ -2452,6 +2568,7 @@ public final Single doOnSubscribe(final Consumer onSubscr
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Single doOnSuccess(final Consumer onSuccess) {
         ObjectHelper.requireNonNull(onSuccess, "onSuccess is null");
@@ -2461,6 +2578,8 @@ public final Single doOnSuccess(final Consumer onSuccess) {
     /**
      * Calls the shared consumer with the error sent via onError or the value
      * via onSuccess for each SingleObserver that subscribes to the current Single.
+     * 

+     * 
      * 

      * 
Scheduler:

      * 
{@code doOnEvent} does not operate by default on a particular {@link Scheduler}.

@@ -2470,6 +2589,7 @@ public final Single doOnSuccess(final Consumer onSuccess) {
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Single doOnEvent(final BiConsumer onEvent) {
         ObjectHelper.requireNonNull(onEvent, "onEvent is null");
@@ -2491,6 +2611,7 @@ public final Single doOnEvent(final BiConsumer
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Single doOnError(final Consumer onError) {
         ObjectHelper.requireNonNull(onError, "onError is null");
@@ -2513,6 +2634,7 @@ public final Single doOnError(final Consumer onError) {
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Single doOnDispose(final Action onDispose) {
         ObjectHelper.requireNonNull(onDispose, "onDispose is null");
@@ -2537,6 +2659,7 @@ public final Single doOnDispose(final Action onDispose) {
      * @see ReactiveX operators documentation: Filter
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Maybe filter(Predicate predicate) {
         ObjectHelper.requireNonNull(predicate, "predicate is null");
@@ -2560,6 +2683,7 @@ public final Maybe filter(Predicate predicate) {
      * @see ReactiveX operators documentation: FlatMap
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final  Single flatMap(Function> mapper) {
         ObjectHelper.requireNonNull(mapper, "mapper is null");
@@ -2583,6 +2707,7 @@ public final  Single flatMap(FunctionReactiveX operators documentation: FlatMap
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final  Maybe flatMapMaybe(final Function> mapper) {
         ObjectHelper.requireNonNull(mapper, "mapper is null");
@@ -2611,6 +2736,7 @@ public final  Maybe flatMapMaybe(final Function Flowable flatMapPublisher(Function> mapper) {
         ObjectHelper.requireNonNull(mapper, "mapper is null");
@@ -2618,8 +2744,8 @@ public final  Flowable flatMapPublisher(Function
      * 
      * 

@@ -2639,6 +2765,7 @@ public final  Flowable flatMapPublisher(Function Flowable flattenAsFlowable(final Function> mapper) {
         ObjectHelper.requireNonNull(mapper, "mapper is null");
@@ -2646,7 +2773,8 @@ public final  Flowable flattenAsFlowable(final Function
      * 
      * 

@@ -2663,6 +2791,7 @@ public final  Flowable flattenAsFlowable(final FunctionReactiveX operators documentation: FlatMap
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final  Observable flattenAsObservable(final Function> mapper) {
         ObjectHelper.requireNonNull(mapper, "mapper is null");
@@ -2686,6 +2815,7 @@ public final  Observable flattenAsObservable(final FunctionReactiveX operators documentation: FlatMap
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final  Observable flatMapObservable(Function> mapper) {
         ObjectHelper.requireNonNull(mapper, "mapper is null");
@@ -2710,6 +2840,7 @@ public final  Observable flatMapObservable(Function mapper) {
         ObjectHelper.requireNonNull(mapper, "mapper is null");
@@ -2719,6 +2850,8 @@ public final Completable flatMapCompletable(final Function
+     * 
      * 

      * 
Scheduler:

      * 
{@code blockingGet} does not operate by default on a particular {@link Scheduler}.

@@ -2746,6 +2879,8 @@ public final T blockingGet() {
      * and providing a new {@code SingleObserver}, containing the custom operator's intended business logic, that will be
      * used in the subscription process going further upstream.
      * 

+     * 
+     * 

      * Generally, such a new {@code SingleObserver} will wrap the downstream's {@code SingleObserver} and forwards the
      * {@code onSuccess} and {@code onError} events from the upstream directly or according to the
      * emission pattern the custom operator's business logic requires. In addition, such operator can intercept the
@@ -2879,9 +3014,10 @@ public final T blockingGet() {
      * @see #compose(SingleTransformer)
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final  Single lift(final SingleOperator lift) {
-        ObjectHelper.requireNonNull(lift, "onLift is null");
+        ObjectHelper.requireNonNull(lift, "lift is null");
         return RxJavaPlugins.onAssembly(new SingleLift(this, lift));
     }
 
@@ -2902,6 +3038,7 @@ public final  Single lift(final SingleOperator lif
      * @see ReactiveX operators documentation: Map
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final  Single map(Function mapper) {
         ObjectHelper.requireNonNull(mapper, "mapper is null");
@@ -2931,6 +3068,8 @@ public final Single> materialize() {
     /**
      * Signals true if the current Single signals a success value that is Object-equals with the value
      * provided.
+     * 

+     * 
      * 

      * 
Scheduler:

      * 
{@code contains} does not operate by default on a particular {@link Scheduler}.

@@ -2948,6 +3087,8 @@ public final Single contains(Object value) {
     /**
      * Signals true if the current Single signals a success value that is equal with
      * the value provided by calling a bi-predicate.
+     * 

+     * 
      * 

      * 
Scheduler:

      * 
{@code contains} does not operate by default on a particular {@link Scheduler}.

@@ -2959,6 +3100,7 @@ public final Single contains(Object value) {
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Single contains(final Object value, final BiPredicate comparer) {
         ObjectHelper.requireNonNull(value, "value is null");
@@ -3012,6 +3154,7 @@ public final Flowable mergeWith(SingleSource other) {
      * @see #subscribeOn
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.CUSTOM)
     public final Single observeOn(final Scheduler scheduler) {
         ObjectHelper.requireNonNull(scheduler, "scheduler is null");
@@ -3045,6 +3188,7 @@ public final Single observeOn(final Scheduler scheduler) {
      * @see ReactiveX operators documentation: Catch
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Single onErrorReturn(final Function resumeFunction) {
         ObjectHelper.requireNonNull(resumeFunction, "resumeFunction is null");
@@ -3064,6 +3208,7 @@ public final Single onErrorReturn(final Function resu
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Single onErrorReturnItem(final T value) {
         ObjectHelper.requireNonNull(value, "value is null");
@@ -3098,6 +3243,7 @@ public final Single onErrorReturnItem(final T value) {
      * @see ReactiveX operators documentation: Catch
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Single onErrorResumeNext(final Single resumeSingleInCaseOfError) {
         ObjectHelper.requireNonNull(resumeSingleInCaseOfError, "resumeSingleInCaseOfError is null");
@@ -3133,6 +3279,7 @@ public final Single onErrorResumeNext(final Single resumeSingleI
      * @since .20
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Single onErrorResumeNext(
             final Function> resumeFunctionInCaseOfError) {
@@ -3143,6 +3290,8 @@ public final Single onErrorResumeNext(
     /**
      * Nulls out references to the upstream producer and downstream SingleObserver if
      * the sequence is terminated or downstream calls dispose().
+     * 

+     * 
      * 

      *  
Scheduler:

      *  
{@code onTerminateDetach} does not operate by default on a particular {@link Scheduler}.

@@ -3250,6 +3399,8 @@ public final Flowable repeatUntil(BooleanSupplier stop) {
 
     /**
      * Repeatedly re-subscribes to the current Single indefinitely if it fails with an onError.
+     * 

+     * 
      * 

      * 
Scheduler:

      * 
{@code retry} does not operate by default on a particular {@link Scheduler}.

@@ -3266,6 +3417,8 @@ public final Single retry() {
     /**
      * Repeatedly re-subscribe at most the specified times to the current Single
      * if it fails with an onError.
+     * 

+     * 
      * 

      * 
Scheduler:

      * 
{@code retry} does not operate by default on a particular {@link Scheduler}.

@@ -3283,6 +3436,8 @@ public final Single retry(long times) {
     /**
      * Re-subscribe to the current Single if the given predicate returns true when the Single fails
      * with an onError.
+     * 

+     * 
      * 

      * 
Scheduler:

      * 
{@code retry} does not operate by default on a particular {@link Scheduler}.

@@ -3301,6 +3456,8 @@ public final Single retry(BiPredicate pre
     /**
      * Repeatedly re-subscribe at most times or until the predicate returns false, whichever happens first
      * if it fails with an onError.
+     * 

+     * 
      * 

      * 
Scheduler:

      * 
{@code retry} does not operate by default on a particular {@link Scheduler}.

@@ -3321,6 +3478,8 @@ public final Single retry(long times, Predicate predicate)
     /**
      * Re-subscribe to the current Single if the given predicate returns true when the Single fails
      * with an onError.
+     * 

+     * 
      * 

      * 
Scheduler:

      * 
{@code retry} does not operate by default on a particular {@link Scheduler}.

@@ -3340,6 +3499,8 @@ public final Single retry(Predicate predicate) {
      * Re-subscribes to the current Single if and when the Publisher returned by the handler
      * function signals a value.
      * 

+     * 
+     * 

      * If the Publisher signals an onComplete, the resulting Single will signal a NoSuchElementException.
      * 

      * Note that the inner {@code Publisher} returned by the handler function should signal
@@ -3386,6 +3547,8 @@ public final Single retryWhen(Function, ? extends
     /**
      * Subscribes to a Single but ignore its emission or notification.
      * 

+     * 
+     * 

      * If the Single emits an error, it is wrapped into an
      * {@link io.reactivex.exceptions.OnErrorNotImplementedException OnErrorNotImplementedException}
      * and routed to the RxJavaPlugins.onError handler.
@@ -3405,6 +3568,8 @@ public final Disposable subscribe() {
     /**
      * Subscribes to a Single and provides a composite callback to handle the item it emits
      * or any error notification it issues.
+     * 

+     * 
      * 

      * 
Scheduler:

      * 
{@code subscribe} does not operate by default on a particular {@link Scheduler}.

@@ -3419,6 +3584,7 @@ public final Disposable subscribe() {
      *             if {@code onCallback} is null
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Disposable subscribe(final BiConsumer onCallback) {
         ObjectHelper.requireNonNull(onCallback, "onCallback is null");
@@ -3431,6 +3597,8 @@ public final Disposable subscribe(final BiConsumer
     /**
      * Subscribes to a Single and provides a callback to handle the item it emits.
      * 

+     * 
+     * 

      * If the Single emits an error, it is wrapped into an
      * {@link io.reactivex.exceptions.OnErrorNotImplementedException OnErrorNotImplementedException}
      * and routed to the RxJavaPlugins.onError handler.
@@ -3455,6 +3623,8 @@ public final Disposable subscribe(Consumer onSuccess) {
     /**
      * Subscribes to a Single and provides callbacks to handle the item it emits or any error notification it
      * issues.
+     * 

+     * 
      * 

      * 
Scheduler:

      * 
{@code subscribe} does not operate by default on a particular {@link Scheduler}.

@@ -3472,6 +3642,7 @@ public final Disposable subscribe(Consumer onSuccess) {
      *             if {@code onError} is null
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Disposable subscribe(final Consumer onSuccess, final Consumer onError) {
         ObjectHelper.requireNonNull(onSuccess, "onSuccess is null");
@@ -3485,7 +3656,7 @@ public final Disposable subscribe(final Consumer onSuccess, final Con
     @SchedulerSupport(SchedulerSupport.NONE)
     @Override
     public final void subscribe(SingleObserver observer) {
-        ObjectHelper.requireNonNull(observer, "subscriber is null");
+        ObjectHelper.requireNonNull(observer, "observer is null");
 
         observer = RxJavaPlugins.onSubscribe(this, observer);
 
@@ -3515,6 +3686,8 @@ public final void subscribe(SingleObserver observer) {
     /**
      * Subscribes a given SingleObserver (subclass) to this Single and returns the given
      * SingleObserver as is.
+     * 

+     * 
      * 
Usage example:
      * 

      * Single<Integer> source = Single.just(1);
@@ -3560,6 +3733,7 @@ public final > E subscribeWith(E observer) {
      * @see #observeOn
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.CUSTOM)
     public final Single subscribeOn(final Scheduler scheduler) {
         ObjectHelper.requireNonNull(scheduler, "scheduler is null");
@@ -3571,7 +3745,7 @@ public final Single subscribeOn(final Scheduler scheduler) {
      * termination of {@code other}, this will emit a {@link CancellationException} rather than go to
      * {@link SingleObserver#onSuccess(Object)}.
      * 

-     * 
+     * 
      * 

      *  
Scheduler:

      *  
{@code takeUntil} does not operate by default on a particular {@link Scheduler}.

@@ -3584,6 +3758,7 @@ public final Single subscribeOn(final Scheduler scheduler) {
      * @see ReactiveX operators documentation: TakeUntil
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Single takeUntil(final CompletableSource other) {
         ObjectHelper.requireNonNull(other, "other is null");
@@ -3595,7 +3770,7 @@ public final Single takeUntil(final CompletableSource other) {
      * emission of an item from {@code other}, this will emit a {@link CancellationException} rather than go to
      * {@link SingleObserver#onSuccess(Object)}.
      * 

-     * 
+     * 
      * 

      *  
Backpressure:

      *  
The {@code other} publisher is consumed in an unbounded fashion but will be
@@ -3615,6 +3790,7 @@ public final Single takeUntil(final CompletableSource other) {
      */
     @BackpressureSupport(BackpressureKind.FULL)
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final  Single takeUntil(final Publisher other) {
         ObjectHelper.requireNonNull(other, "other is null");
@@ -3626,7 +3802,7 @@ public final  Single takeUntil(final Publisher other) {
      * emission of an item from {@code other}, this will emit a {@link CancellationException} rather than go to
      * {@link SingleObserver#onSuccess(Object)}.
      * 

-     * 
+     * 
      * 

      *  
Scheduler:

      *  
{@code takeUntil} does not operate by default on a particular {@link Scheduler}.

@@ -3640,6 +3816,7 @@ public final  Single takeUntil(final Publisher other) {
      * @see ReactiveX operators documentation: TakeUntil
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public final  Single takeUntil(final SingleSource other) {
         ObjectHelper.requireNonNull(other, "other is null");
@@ -3649,6 +3826,8 @@ public final  Single takeUntil(final SingleSource other) {
     /**
      * Signals a TimeoutException if the current Single doesn't signal a success value within the
      * specified timeout window.
+     * 

+     * 
      * 

      *  
Scheduler:

      *  
{@code timeout} signals the TimeoutException on the {@code computation} {@link Scheduler}.

@@ -3667,6 +3846,8 @@ public final Single timeout(long timeout, TimeUnit unit) {
     /**
      * Signals a TimeoutException if the current Single doesn't signal a success value within the
      * specified timeout window.
+     * 

+     * 
      * 

      *  
Scheduler:

      *  
{@code timeout} signals the TimeoutException on the {@link Scheduler} you specify.

@@ -3687,6 +3868,8 @@ public final Single timeout(long timeout, TimeUnit unit, Scheduler scheduler)
     /**
      * Runs the current Single and if it doesn't signal within the specified timeout window, it is
      * disposed and the other SingleSource subscribed to.
+     * 

+     * 
      * 

      *  
Scheduler:

      *  
{@code timeout} subscribes to the other SingleSource on the {@link Scheduler} you specify.

@@ -3699,6 +3882,7 @@ public final Single timeout(long timeout, TimeUnit unit, Scheduler scheduler)
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.CUSTOM)
     public final Single timeout(long timeout, TimeUnit unit, Scheduler scheduler, SingleSource other) {
         ObjectHelper.requireNonNull(other, "other is null");
@@ -3708,6 +3892,8 @@ public final Single timeout(long timeout, TimeUnit unit, Scheduler scheduler,
     /**
      * Runs the current Single and if it doesn't signal within the specified timeout window, it is
      * disposed and the other SingleSource subscribed to.
+     * 

+     * 
      * 

      *  
Scheduler:

      *  
{@code timeout} subscribes to the other SingleSource on
@@ -3724,6 +3910,7 @@ public final Single timeout(long timeout, TimeUnit unit, Scheduler scheduler,
      * @since 2.0
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.COMPUTATION)
     public final Single timeout(long timeout, TimeUnit unit, SingleSource other) {
         ObjectHelper.requireNonNull(other, "other is null");
@@ -3891,6 +4078,8 @@ public final Observable toObservable() {
     /**
      * Returns a Single which makes sure when a SingleObserver disposes the Disposable,
      * that call is propagated up on the specified scheduler.
+     * 

+     * 
      * 

      *  
Scheduler:

      *  
{@code unsubscribeOn} calls dispose() of the upstream on the {@link Scheduler} you specify.

@@ -3902,6 +4091,7 @@ public final Observable toObservable() {
      * @since 2.2
      */
     @CheckReturnValue
+    @NonNull
     @SchedulerSupport(SchedulerSupport.CUSTOM)
     public final Single unsubscribeOn(final Scheduler scheduler) {
         ObjectHelper.requireNonNull(scheduler, "scheduler is null");
@@ -3943,6 +4133,8 @@ public final  Single zipWith(SingleSource other, BiFunction
+     * 
      * 

      *  
Scheduler:

      *  
{@code test} does not operate by default on a particular {@link Scheduler}.

@@ -3960,6 +4152,8 @@ public final TestObserver test() {
 
     /**
      * Creates a TestObserver optionally in cancelled state, then subscribes it to this Single.
+     * 

+     * 
      * 

      *  
Scheduler:

      *  
{@code test} does not operate by default on a particular {@link Scheduler}.

diff --git a/src/main/java/io/reactivex/disposables/ActionDisposable.java b/src/main/java/io/reactivex/disposables/ActionDisposable.java
index 447dfe2e34..f553f8b58e 100644
--- a/src/main/java/io/reactivex/disposables/ActionDisposable.java
+++ b/src/main/java/io/reactivex/disposables/ActionDisposable.java
@@ -16,6 +16,9 @@
 import io.reactivex.functions.Action;
 import io.reactivex.internal.util.ExceptionHelper;
 
+/**
+ * A Disposable container that manages an Action instance.
+ */
 final class ActionDisposable extends ReferenceDisposable {
 
     private static final long serialVersionUID = -8219729196779211169L;
diff --git a/src/main/java/io/reactivex/disposables/CompositeDisposable.java b/src/main/java/io/reactivex/disposables/CompositeDisposable.java
index 5bed43ec77..f7a1bf4a36 100644
--- a/src/main/java/io/reactivex/disposables/CompositeDisposable.java
+++ b/src/main/java/io/reactivex/disposables/CompositeDisposable.java
@@ -38,26 +38,28 @@ public CompositeDisposable() {
 
     /**
      * Creates a CompositeDisposables with the given array of initial elements.
-     * @param resources the array of Disposables to start with
+     * @param disposables the array of Disposables to start with
+     * @throws NullPointerException if {@code disposables} or any of its array items is null
      */
-    public CompositeDisposable(@NonNull Disposable... resources) {
-        ObjectHelper.requireNonNull(resources, "resources is null");
-        this.resources = new OpenHashSet(resources.length + 1);
-        for (Disposable d : resources) {
-            ObjectHelper.requireNonNull(d, "Disposable item is null");
+    public CompositeDisposable(@NonNull Disposable... disposables) {
+        ObjectHelper.requireNonNull(disposables, "disposables is null");
+        this.resources = new OpenHashSet(disposables.length + 1);
+        for (Disposable d : disposables) {
+            ObjectHelper.requireNonNull(d, "A Disposable in the disposables array is null");
             this.resources.add(d);
         }
     }
 
     /**
      * Creates a CompositeDisposables with the given Iterable sequence of initial elements.
-     * @param resources the Iterable sequence of Disposables to start with
+     * @param disposables the Iterable sequence of Disposables to start with
+     * @throws NullPointerException if {@code disposables} or any of its items is null
      */
-    public CompositeDisposable(@NonNull Iterable resources) {
-        ObjectHelper.requireNonNull(resources, "resources is null");
+    public CompositeDisposable(@NonNull Iterable disposables) {
+        ObjectHelper.requireNonNull(disposables, "disposables is null");
         this.resources = new OpenHashSet();
-        for (Disposable d : resources) {
-            ObjectHelper.requireNonNull(d, "Disposable item is null");
+        for (Disposable d : disposables) {
+            ObjectHelper.requireNonNull(d, "A Disposable item in the disposables sequence is null");
             this.resources.add(d);
         }
     }
@@ -88,12 +90,13 @@ public boolean isDisposed() {
     /**
      * Adds a disposable to this container or disposes it if the
      * container has been disposed.
-     * @param d the disposable to add, not null
+     * @param disposable the disposable to add, not null
      * @return true if successful, false if this container has been disposed
+     * @throws NullPointerException if {@code disposable} is null
      */
     @Override
-    public boolean add(@NonNull Disposable d) {
-        ObjectHelper.requireNonNull(d, "d is null");
+    public boolean add(@NonNull Disposable disposable) {
+        ObjectHelper.requireNonNull(disposable, "disposable is null");
         if (!disposed) {
             synchronized (this) {
                 if (!disposed) {
@@ -102,40 +105,41 @@ public boolean add(@NonNull Disposable d) {
                         set = new OpenHashSet();
                         resources = set;
                     }
-                    set.add(d);
+                    set.add(disposable);
                     return true;
                 }
             }
         }
-        d.dispose();
+        disposable.dispose();
         return false;
     }
 
     /**
      * Atomically adds the given array of Disposables to the container or
      * disposes them all if the container has been disposed.
-     * @param ds the array of Disposables
+     * @param disposables the array of Disposables
      * @return true if the operation was successful, false if the container has been disposed
+     * @throws NullPointerException if {@code disposables} or any of its array items is null
      */
-    public boolean addAll(@NonNull Disposable... ds) {
-        ObjectHelper.requireNonNull(ds, "ds is null");
+    public boolean addAll(@NonNull Disposable... disposables) {
+        ObjectHelper.requireNonNull(disposables, "disposables is null");
         if (!disposed) {
             synchronized (this) {
                 if (!disposed) {
                     OpenHashSet set = resources;
                     if (set == null) {
-                        set = new OpenHashSet(ds.length + 1);
+                        set = new OpenHashSet(disposables.length + 1);
                         resources = set;
                     }
-                    for (Disposable d : ds) {
-                        ObjectHelper.requireNonNull(d, "d is null");
+                    for (Disposable d : disposables) {
+                        ObjectHelper.requireNonNull(d, "A Disposable in the disposables array is null");
                         set.add(d);
                     }
                     return true;
                 }
             }
         }
-        for (Disposable d : ds) {
+        for (Disposable d : disposables) {
             d.dispose();
         }
         return false;
@@ -144,13 +148,13 @@ public boolean addAll(@NonNull Disposable... ds) {
     /**
      * Removes and disposes the given disposable if it is part of this
      * container.
-     * @param d the disposable to remove and dispose, not null
+     * @param disposable the disposable to remove and dispose, not null
      * @return true if the operation was successful
      */
     @Override
-    public boolean remove(@NonNull Disposable d) {
-        if (delete(d)) {
-            d.dispose();
+    public boolean remove(@NonNull Disposable disposable) {
+        if (delete(disposable)) {
+            disposable.dispose();
             return true;
         }
         return false;
@@ -159,12 +163,13 @@ public boolean remove(@NonNull Disposable d) {
     /**
      * Removes (but does not dispose) the given disposable if it is part of this
      * container.
-     * @param d the disposable to remove, not null
+     * @param disposable the disposable to remove, not null
      * @return true if the operation was successful
+     * @throws NullPointerException if {@code disposable} is null
      */
     @Override
-    public boolean delete(@NonNull Disposable d) {
-        ObjectHelper.requireNonNull(d, "Disposable item is null");
+    public boolean delete(@NonNull Disposable disposable) {
+        ObjectHelper.requireNonNull(disposable, "disposables is null");
         if (disposed) {
             return false;
         }
@@ -174,7 +179,7 @@ public boolean delete(@NonNull Disposable d) {
             }
 
             OpenHashSet set = resources;
-            if (set == null || !set.remove(d)) {
+            if (set == null || !set.remove(disposable)) {
                 return false;
             }
         }
diff --git a/src/main/java/io/reactivex/exceptions/CompositeException.java b/src/main/java/io/reactivex/exceptions/CompositeException.java
index 748b964cf7..4915688379 100644
--- a/src/main/java/io/reactivex/exceptions/CompositeException.java
+++ b/src/main/java/io/reactivex/exceptions/CompositeException.java
@@ -280,7 +280,7 @@ public int size() {
      */
     /*private */Throwable getRootCause(Throwable e) {
         Throwable root = e.getCause();
-        if (root == null || cause == root) {
+        if (root == null || e == root) {
             return e;
         }
         while (true) {
diff --git a/src/main/java/io/reactivex/exceptions/ProtocolViolationException.java b/src/main/java/io/reactivex/exceptions/ProtocolViolationException.java
index 09c0361108..ff36ce1cf3 100644
--- a/src/main/java/io/reactivex/exceptions/ProtocolViolationException.java
+++ b/src/main/java/io/reactivex/exceptions/ProtocolViolationException.java
@@ -14,7 +14,7 @@
 package io.reactivex.exceptions;
 
 /**
- * Explicitly named exception to indicate a Reactive-Streams
+ * Explicitly named exception to indicate a Reactive Streams
  * protocol violation.
  * 
History: 2.0.6 - experimental; 2.1 - beta
  * @since 2.2
diff --git a/src/main/java/io/reactivex/flowables/ConnectableFlowable.java b/src/main/java/io/reactivex/flowables/ConnectableFlowable.java
index 21636e67da..ef5b667bac 100644
--- a/src/main/java/io/reactivex/flowables/ConnectableFlowable.java
+++ b/src/main/java/io/reactivex/flowables/ConnectableFlowable.java
@@ -68,6 +68,24 @@ public final Disposable connect() {
         return cc.disposable;
     }
 
+    /**
+     * Apply a workaround for a race condition with the regular publish().refCount()
+     * so that racing subscribers and refCount won't hang.
+     * 
+     * @return the ConnectableFlowable to work with
+     * @since 2.2.10
+     */
+    private ConnectableFlowable onRefCount() {
+        if (this instanceof FlowablePublishClassic) {
+            @SuppressWarnings("unchecked")
+            FlowablePublishClassic fp = (FlowablePublishClassic) this;
+            return RxJavaPlugins.onAssembly(
+                    new FlowablePublishAlt(fp.publishSource(), fp.publishBufferSize())
+                    );
+        }
+        return this;
+    }
+
     /**
      * Returns a {@code Flowable} that stays connected to this {@code ConnectableFlowable} as long as there
      * is at least one subscription to this {@code ConnectableFlowable}.
@@ -89,7 +107,7 @@ public final Disposable connect() {
     @SchedulerSupport(SchedulerSupport.NONE)
     @BackpressureSupport(BackpressureKind.PASS_THROUGH)
     public Flowable refCount() {
-        return RxJavaPlugins.onAssembly(new FlowableRefCount(this));
+        return RxJavaPlugins.onAssembly(new FlowableRefCount(onRefCount()));
     }
 
     /**
@@ -216,7 +234,7 @@ public final Flowable refCount(int subscriberCount, long timeout, TimeUnit un
         ObjectHelper.verifyPositive(subscriberCount, "subscriberCount");
         ObjectHelper.requireNonNull(unit, "unit is null");
         ObjectHelper.requireNonNull(scheduler, "scheduler is null");
-        return RxJavaPlugins.onAssembly(new FlowableRefCount(this, subscriberCount, timeout, unit, scheduler));
+        return RxJavaPlugins.onAssembly(new FlowableRefCount(onRefCount(), subscriberCount, timeout, unit, scheduler));
     }
 
     /**
diff --git a/src/main/java/io/reactivex/internal/operators/completable/CompletableAmb.java b/src/main/java/io/reactivex/internal/operators/completable/CompletableAmb.java
index cc603acbdc..7de1c648e4 100644
--- a/src/main/java/io/reactivex/internal/operators/completable/CompletableAmb.java
+++ b/src/main/java/io/reactivex/internal/operators/completable/CompletableAmb.java
@@ -63,8 +63,6 @@ public void subscribeActual(final CompletableObserver observer) {
 
         final AtomicBoolean once = new AtomicBoolean();
 
-        CompletableObserver inner = new Amb(once, set, observer);
-
         for (int i = 0; i < count; i++) {
             CompletableSource c = sources[i];
             if (set.isDisposed()) {
@@ -82,7 +80,7 @@ public void subscribeActual(final CompletableObserver observer) {
             }
 
             // no need to have separate subscribers because inner is stateless
-            c.subscribe(inner);
+            c.subscribe(new Amb(once, set, observer));
         }
 
         if (count == 0) {
@@ -91,9 +89,14 @@ public void subscribeActual(final CompletableObserver observer) {
     }
 
     static final class Amb implements CompletableObserver {
-        private final AtomicBoolean once;
-        private final CompositeDisposable set;
-        private final CompletableObserver downstream;
+
+        final AtomicBoolean once;
+
+        final CompositeDisposable set;
+
+        final CompletableObserver downstream;
+
+        Disposable upstream;
 
         Amb(AtomicBoolean once, CompositeDisposable set, CompletableObserver observer) {
             this.once = once;
@@ -104,6 +107,7 @@ static final class Amb implements CompletableObserver {
         @Override
         public void onComplete() {
             if (once.compareAndSet(false, true)) {
+                set.delete(upstream);
                 set.dispose();
                 downstream.onComplete();
             }
@@ -112,6 +116,7 @@ public void onComplete() {
         @Override
         public void onError(Throwable e) {
             if (once.compareAndSet(false, true)) {
+                set.delete(upstream);
                 set.dispose();
                 downstream.onError(e);
             } else {
@@ -121,8 +126,8 @@ public void onError(Throwable e) {
 
         @Override
         public void onSubscribe(Disposable d) {
+            upstream = d;
             set.add(d);
         }
-
     }
 }
diff --git a/src/main/java/io/reactivex/internal/operators/completable/CompletableAndThenCompletable.java b/src/main/java/io/reactivex/internal/operators/completable/CompletableAndThenCompletable.java
new file mode 100644
index 0000000000..ff7b6cced5
--- /dev/null
+++ b/src/main/java/io/reactivex/internal/operators/completable/CompletableAndThenCompletable.java
@@ -0,0 +1,107 @@
+/**
+ * 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.internal.operators.completable;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+import io.reactivex.*;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+
+public final class CompletableAndThenCompletable extends Completable {
+
+    final CompletableSource source;
+
+    final CompletableSource next;
+
+    public CompletableAndThenCompletable(CompletableSource source, CompletableSource next) {
+        this.source = source;
+        this.next = next;
+    }
+
+    @Override
+    protected void subscribeActual(CompletableObserver observer) {
+        source.subscribe(new SourceObserver(observer, next));
+    }
+
+    static final class SourceObserver
+            extends AtomicReference
+            implements CompletableObserver, Disposable {
+
+        private static final long serialVersionUID = -4101678820158072998L;
+
+        final CompletableObserver actualObserver;
+
+        final CompletableSource next;
+
+        SourceObserver(CompletableObserver actualObserver, CompletableSource next) {
+            this.actualObserver = actualObserver;
+            this.next = next;
+        }
+
+        @Override
+        public void onSubscribe(Disposable d) {
+            if (DisposableHelper.setOnce(this, d)) {
+                actualObserver.onSubscribe(this);
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            actualObserver.onError(e);
+        }
+
+        @Override
+        public void onComplete() {
+            next.subscribe(new NextObserver(this, actualObserver));
+        }
+
+        @Override
+        public void dispose() {
+            DisposableHelper.dispose(this);
+        }
+
+        @Override
+        public boolean isDisposed() {
+            return DisposableHelper.isDisposed(get());
+        }
+    }
+
+    static final class NextObserver implements CompletableObserver {
+
+        final AtomicReference parent;
+
+        final CompletableObserver downstream;
+
+        NextObserver(AtomicReference parent, CompletableObserver downstream) {
+            this.parent = parent;
+            this.downstream = downstream;
+        }
+
+        @Override
+        public void onSubscribe(Disposable d) {
+            DisposableHelper.replace(parent, d);
+        }
+
+        @Override
+        public void onComplete() {
+            downstream.onComplete();
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            downstream.onError(e);
+        }
+    }
+}
diff --git a/src/main/java/io/reactivex/internal/operators/completable/CompletableFromAction.java b/src/main/java/io/reactivex/internal/operators/completable/CompletableFromAction.java
index 3e49bf0ec6..6722722390 100644
--- a/src/main/java/io/reactivex/internal/operators/completable/CompletableFromAction.java
+++ b/src/main/java/io/reactivex/internal/operators/completable/CompletableFromAction.java
@@ -17,6 +17,7 @@
 import io.reactivex.disposables.*;
 import io.reactivex.exceptions.Exceptions;
 import io.reactivex.functions.Action;
+import io.reactivex.plugins.RxJavaPlugins;
 
 public final class CompletableFromAction extends Completable {
 
@@ -36,6 +37,8 @@ protected void subscribeActual(CompletableObserver observer) {
             Exceptions.throwIfFatal(e);
             if (!d.isDisposed()) {
                 observer.onError(e);
+            } else {
+                RxJavaPlugins.onError(e);
             }
             return;
         }
diff --git a/src/main/java/io/reactivex/internal/operators/completable/CompletableFromRunnable.java b/src/main/java/io/reactivex/internal/operators/completable/CompletableFromRunnable.java
index 981e6d1f1f..3ce78a167f 100644
--- a/src/main/java/io/reactivex/internal/operators/completable/CompletableFromRunnable.java
+++ b/src/main/java/io/reactivex/internal/operators/completable/CompletableFromRunnable.java
@@ -18,6 +18,7 @@
 import io.reactivex.disposables.Disposable;
 import io.reactivex.disposables.Disposables;
 import io.reactivex.exceptions.Exceptions;
+import io.reactivex.plugins.RxJavaPlugins;
 
 public final class CompletableFromRunnable extends Completable {
 
@@ -37,6 +38,8 @@ protected void subscribeActual(CompletableObserver observer) {
             Exceptions.throwIfFatal(e);
             if (!d.isDisposed()) {
                 observer.onError(e);
+            } else {
+                RxJavaPlugins.onError(e);
             }
             return;
         }
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/BlockingFlowableIterable.java b/src/main/java/io/reactivex/internal/operators/flowable/BlockingFlowableIterable.java
index af6613b224..d09af33ee0 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/BlockingFlowableIterable.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/BlockingFlowableIterable.java
@@ -62,7 +62,7 @@ static final class BlockingFlowableIterator
         long produced;
 
         volatile boolean done;
-        Throwable error;
+        volatile Throwable error;
 
         BlockingFlowableIterator(int batchSize) {
             this.queue = new SpscArrayQueue(batchSize);
@@ -75,6 +75,13 @@ static final class BlockingFlowableIterator
         @Override
         public boolean hasNext() {
             for (;;) {
+                if (isDisposed()) {
+                    Throwable e = error;
+                    if (e != null) {
+                        throw ExceptionHelper.wrapOrThrow(e);
+                    }
+                    return false;
+                }
                 boolean d = done;
                 boolean empty = queue.isEmpty();
                 if (d) {
@@ -90,7 +97,7 @@ public boolean hasNext() {
                     BlockingHelper.verifyNonBlocking();
                     lock.lock();
                     try {
-                        while (!done && queue.isEmpty()) {
+                        while (!done && queue.isEmpty() && !isDisposed()) {
                             condition.await();
                         }
                     } catch (InterruptedException ex) {
@@ -175,6 +182,7 @@ public void remove() {
         @Override
         public void dispose() {
             SubscriptionHelper.cancel(this);
+            signalConsumer();
         }
 
         @Override
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/BlockingFlowableMostRecent.java b/src/main/java/io/reactivex/internal/operators/flowable/BlockingFlowableMostRecent.java
index 298a3f21be..235d8507dc 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/BlockingFlowableMostRecent.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/BlockingFlowableMostRecent.java
@@ -42,10 +42,6 @@ public BlockingFlowableMostRecent(Flowable source, T initialValue) {
     public Iterator iterator() {
         MostRecentSubscriber mostRecentSubscriber = new MostRecentSubscriber(initialValue);
 
-        /**
-         * Subscribe instead of unsafeSubscribe since this is the final subscribe in the chain
-         * since it is for BlockingObservable.
-         */
         source.subscribe(mostRecentSubscriber);
 
         return mostRecentSubscriber.getIterable();
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableBufferTimed.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableBufferTimed.java
index 4e3be8a9e5..06736603f1 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableBufferTimed.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableBufferTimed.java
@@ -501,13 +501,14 @@ public void onComplete() {
                 buffer = null;
             }
 
-            queue.offer(b);
-            done = true;
-            if (enter()) {
-                QueueDrainHelper.drainMaxLoop(queue, downstream, false, this, this);
+            if (b != null) {
+                queue.offer(b);
+                done = true;
+                if (enter()) {
+                    QueueDrainHelper.drainMaxLoop(queue, downstream, false, this, this);
+                }
+                w.dispose();
             }
-
-            w.dispose();
         }
 
         @Override
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableConcatMap.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableConcatMap.java
index 2dc316d1e9..64df7cc122 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableConcatMap.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableConcatMap.java
@@ -13,7 +13,7 @@
 package io.reactivex.internal.operators.flowable;
 
 import java.util.concurrent.Callable;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.*;
 
 import org.reactivestreams.*;
 
@@ -332,7 +332,7 @@ void drain() {
                                     continue;
                                 } else {
                                     active = true;
-                                    inner.setSubscription(new WeakScalarSubscription(vr, inner));
+                                    inner.setSubscription(new SimpleScalarSubscription(vr, inner));
                                 }
 
                             } else {
@@ -349,20 +349,20 @@ void drain() {
         }
     }
 
-    static final class WeakScalarSubscription implements Subscription {
+    static final class SimpleScalarSubscription
+    extends AtomicBoolean
+    implements Subscription {
         final Subscriber downstream;
         final T value;
-        boolean once;
 
-        WeakScalarSubscription(T value, Subscriber downstream) {
+        SimpleScalarSubscription(T value, Subscriber downstream) {
             this.value = value;
             this.downstream = downstream;
         }
 
         @Override
         public void request(long n) {
-            if (n > 0 && !once) {
-                once = true;
+            if (n > 0 && compareAndSet(false, true)) {
                 Subscriber a = downstream;
                 a.onNext(value);
                 a.onComplete();
@@ -520,10 +520,13 @@ void drain() {
                                     vr = supplier.call();
                                 } catch (Throwable e) {
                                     Exceptions.throwIfFatal(e);
-                                    upstream.cancel();
                                     errors.addThrowable(e);
-                                    downstream.onError(errors.terminate());
-                                    return;
+                                    if (!veryEnd) {
+                                        upstream.cancel();
+                                        downstream.onError(errors.terminate());
+                                        return;
+                                    }
+                                    vr = null;
                                 }
 
                                 if (vr == null) {
@@ -535,7 +538,7 @@ void drain() {
                                     continue;
                                 } else {
                                     active = true;
-                                    inner.setSubscription(new WeakScalarSubscription(vr, inner));
+                                    inner.setSubscription(new SimpleScalarSubscription(vr, inner));
                                 }
                             } else {
                                 active = true;
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableConcatMapEager.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableConcatMapEager.java
index 87ee235704..8acad8ac69 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableConcatMapEager.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableConcatMapEager.java
@@ -176,7 +176,12 @@ void drainAndCancel() {
         }
 
         void cancelAll() {
-            InnerQueuedSubscriber inner;
+            InnerQueuedSubscriber inner = current;
+            current = null;
+
+            if (inner != null) {
+                inner.cancel();
+            }
 
             while ((inner = subscribers.poll()) != null) {
                 inner.cancel();
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableDebounce.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableDebounce.java
index 92b1c48254..143e61ec55 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableDebounce.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableDebounce.java
@@ -119,7 +119,9 @@ public void onComplete() {
             if (!DisposableHelper.isDisposed(d)) {
                 @SuppressWarnings("unchecked")
                 DebounceInnerSubscriber dis = (DebounceInnerSubscriber)d;
-                dis.emit();
+                if (dis != null) {
+                    dis.emit();
+                }
                 DisposableHelper.dispose(debouncer);
                 downstream.onComplete();
             }
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableFlatMap.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableFlatMap.java
index c68e82bb93..a7631de8b8 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableFlatMap.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableFlatMap.java
@@ -322,6 +322,11 @@ public void onError(Throwable t) {
             }
             if (errs.addThrowable(t)) {
                 done = true;
+                if (!delayErrors) {
+                    for (InnerSubscriber a : subscribers.getAndSet(CANCELLED)) {
+                        a.dispose();
+                    }
+                }
                 drain();
             } else {
                 RxJavaPlugins.onError(t);
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableFromArray.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableFromArray.java
index c8c6201daa..d54fb15a21 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableFromArray.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableFromArray.java
@@ -126,7 +126,7 @@ void fastPath() {
                 }
                 T t = arr[i];
                 if (t == null) {
-                    a.onError(new NullPointerException("array element is null"));
+                    a.onError(new NullPointerException("The element at index " + i + " is null"));
                     return;
                 } else {
                     a.onNext(t);
@@ -156,7 +156,7 @@ void slowPath(long r) {
                     T t = arr[i];
 
                     if (t == null) {
-                        a.onError(new NullPointerException("array element is null"));
+                        a.onError(new NullPointerException("The element at index " + i + " is null"));
                         return;
                     } else {
                         a.onNext(t);
@@ -209,7 +209,7 @@ void fastPath() {
                 }
                 T t = arr[i];
                 if (t == null) {
-                    a.onError(new NullPointerException("array element is null"));
+                    a.onError(new NullPointerException("The element at index " + i + " is null"));
                     return;
                 } else {
                     a.tryOnNext(t);
@@ -239,7 +239,7 @@ void slowPath(long r) {
                     T t = arr[i];
 
                     if (t == null) {
-                        a.onError(new NullPointerException("array element is null"));
+                        a.onError(new NullPointerException("The element at index " + i + " is null"));
                         return;
                     } else {
                         if (a.tryOnNext(t)) {
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableGroupBy.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableGroupBy.java
index 719645afe9..99a63c7b91 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableGroupBy.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableGroupBy.java
@@ -262,7 +262,7 @@ public void cancel(K key) {
             if (groupCount.decrementAndGet() == 0) {
                 upstream.cancel();
 
-                if (getAndIncrement() == 0) {
+                if (!outputFused && getAndIncrement() == 0) {
                     queue.clear();
                 }
             }
@@ -288,7 +288,6 @@ void drainFused() {
 
             for (;;) {
                 if (cancelled.get()) {
-                    q.clear();
                     return;
                 }
 
@@ -519,6 +518,7 @@ public void request(long n) {
         public void cancel() {
             if (cancelled.compareAndSet(false, true)) {
                 parent.cancel(key);
+                drain();
             }
         }
 
@@ -569,7 +569,6 @@ void drainFused() {
             for (;;) {
                 if (a != null) {
                     if (cancelled.get()) {
-                        q.clear();
                         return;
                     }
 
@@ -624,7 +623,7 @@ void drainNormal() {
                         T v = q.poll();
                         boolean empty = v == null;
 
-                        if (checkTerminated(d, empty, a, delayError)) {
+                        if (checkTerminated(d, empty, a, delayError, e)) {
                             return;
                         }
 
@@ -637,7 +636,7 @@ void drainNormal() {
                         e++;
                     }
 
-                    if (e == r && checkTerminated(done, q.isEmpty(), a, delayError)) {
+                    if (e == r && checkTerminated(done, q.isEmpty(), a, delayError, e)) {
                         return;
                     }
 
@@ -659,9 +658,15 @@ void drainNormal() {
             }
         }
 
-        boolean checkTerminated(boolean d, boolean empty, Subscriber a, boolean delayError) {
+        boolean checkTerminated(boolean d, boolean empty, Subscriber a, boolean delayError, long emitted) {
             if (cancelled.get()) {
-                queue.clear();
+                // make sure buffered items can get replenished
+                while (queue.poll() != null) {
+                    emitted++;
+                }
+                if (emitted != 0) {
+                    parent.upstream.request(emitted);
+                }
                 return true;
             }
 
@@ -710,22 +715,35 @@ public T poll() {
                 produced++;
                 return v;
             }
-            int p = produced;
-            if (p != 0) {
-                produced = 0;
-                parent.upstream.request(p);
-            }
+            tryReplenish();
             return null;
         }
 
         @Override
         public boolean isEmpty() {
-            return queue.isEmpty();
+            if (queue.isEmpty()) {
+                tryReplenish();
+                return true;
+            }
+            return false;
+        }
+
+        void tryReplenish() {
+            int p = produced;
+            if (p != 0) {
+                produced = 0;
+                parent.upstream.request(p);
+            }
         }
 
         @Override
         public void clear() {
-            queue.clear();
+            // make sure buffered items can get replenished
+            SpscLinkedArrayQueue q = queue;
+            while (q.poll() != null) {
+                produced++;
+            }
+            tryReplenish();
         }
     }
 }
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableMergeWithCompletable.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableMergeWithCompletable.java
index 271bd9c50d..c65386bbb1 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableMergeWithCompletable.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableMergeWithCompletable.java
@@ -86,7 +86,7 @@ public void onNext(T t) {
 
         @Override
         public void onError(Throwable ex) {
-            SubscriptionHelper.cancel(mainSubscription);
+            DisposableHelper.dispose(otherObserver);
             HalfSerializer.onError(downstream, ex, this, error);
         }
 
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableMergeWithMaybe.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableMergeWithMaybe.java
index a32a0c92fc..1787d5fce3 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableMergeWithMaybe.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableMergeWithMaybe.java
@@ -143,7 +143,7 @@ public void onNext(T t) {
         @Override
         public void onError(Throwable ex) {
             if (error.addThrowable(ex)) {
-                SubscriptionHelper.cancel(mainSubscription);
+                DisposableHelper.dispose(otherObserver);
                 drain();
             } else {
                 RxJavaPlugins.onError(ex);
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableMergeWithSingle.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableMergeWithSingle.java
index 586bc07c07..486cb73f8c 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableMergeWithSingle.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableMergeWithSingle.java
@@ -143,7 +143,7 @@ public void onNext(T t) {
         @Override
         public void onError(Throwable ex) {
             if (error.addThrowable(ex)) {
-                SubscriptionHelper.cancel(mainSubscription);
+                DisposableHelper.dispose(otherObserver);
                 drain();
             } else {
                 RxJavaPlugins.onError(ex);
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableObserveOn.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableObserveOn.java
index 2a7d499d1a..3431f3a50b 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableObserveOn.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableObserveOn.java
@@ -154,7 +154,7 @@ public final void cancel() {
             upstream.cancel();
             worker.dispose();
 
-            if (getAndIncrement() == 0) {
+            if (!outputFused && getAndIncrement() == 0) {
                 queue.clear();
             }
         }
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableOnBackpressureBuffer.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableOnBackpressureBuffer.java
index 20caa2c7e3..8cbb73ebf2 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableOnBackpressureBuffer.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableOnBackpressureBuffer.java
@@ -150,7 +150,7 @@ public void cancel() {
                 cancelled = true;
                 upstream.cancel();
 
-                if (getAndIncrement() == 0) {
+                if (!outputFused && getAndIncrement() == 0) {
                     queue.clear();
                 }
             }
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableOnBackpressureError.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableOnBackpressureError.java
index f60c43bc31..556e54b8c3 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableOnBackpressureError.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableOnBackpressureError.java
@@ -65,6 +65,7 @@ public void onNext(T t) {
                 downstream.onNext(t);
                 BackpressureHelper.produced(this, 1);
             } else {
+                upstream.cancel();
                 onError(new MissingBackpressureException("could not emit value due to lack of requests"));
             }
         }
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowablePublish.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowablePublish.java
index 0e08551495..b325d2b78d 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowablePublish.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowablePublish.java
@@ -33,7 +33,8 @@
  * manner.
  * @param  the value type
  */
-public final class FlowablePublish extends ConnectableFlowable implements HasUpstreamPublisher {
+public final class FlowablePublish extends ConnectableFlowable
+implements HasUpstreamPublisher, FlowablePublishClassic {
     /**
      * Indicates this child has been cancelled: the state is swapped in atomically and
      * will prevent the dispatch() to emit (too many) values to a terminated child subscriber.
@@ -77,6 +78,20 @@ public Publisher source() {
         return source;
     }
 
+    /**
+     * The internal buffer size of this FloawblePublish operator.
+     * @return The internal buffer size of this FloawblePublish operator.
+     */
+    @Override
+    public int publishBufferSize() {
+        return bufferSize;
+    }
+
+    @Override
+    public Publisher publishSource() {
+        return source;
+    }
+
     @Override
     protected void subscribeActual(Subscriber s) {
         onSubscribe.subscribe(s);
@@ -557,12 +572,20 @@ void dispatch() {
                         InnerSubscriber[] freshArray = subscribers.get();
                         if (subscribersChanged || freshArray != ps) {
                             ps = freshArray;
+
+                            // if we did emit at least one element, request more to replenish the queue
+                            if (d != 0) {
+                                if (sourceMode != QueueSubscription.SYNC) {
+                                    upstream.get().request(d);
+                                }
+                            }
+
                             continue outer;
                         }
                     }
 
                     // if we did emit at least one element, request more to replenish the queue
-                    if (d > 0) {
+                    if (d != 0) {
                         if (sourceMode != QueueSubscription.SYNC) {
                             upstream.get().request(d);
                         }
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowablePublishAlt.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowablePublishAlt.java
new file mode 100644
index 0000000000..932e0bf003
--- /dev/null
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowablePublishAlt.java
@@ -0,0 +1,484 @@
+/**
+ * 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.internal.operators.flowable;
+
+import java.util.concurrent.atomic.*;
+
+import org.reactivestreams.*;
+
+import io.reactivex.FlowableSubscriber;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.*;
+import io.reactivex.flowables.ConnectableFlowable;
+import io.reactivex.functions.Consumer;
+import io.reactivex.internal.disposables.ResettableConnectable;
+import io.reactivex.internal.fuseable.*;
+import io.reactivex.internal.queue.SpscArrayQueue;
+import io.reactivex.internal.subscriptions.SubscriptionHelper;
+import io.reactivex.internal.util.*;
+import io.reactivex.plugins.RxJavaPlugins;
+
+/**
+ * Shares a single underlying connection to the upstream Publisher
+ * and multicasts events to all subscribed subscribers until the upstream
+ * completes or the connection is disposed.
+ * 

+ * The difference to FlowablePublish is that when the upstream terminates,
+ * late subscriberss will receive that terminal event until the connection is
+ * disposed and the ConnectableFlowable is reset to its fresh state.
+ *
+ * @param  the element type
+ * @since 2.2.10
+ */
+public final class FlowablePublishAlt extends ConnectableFlowable
+implements HasUpstreamPublisher, ResettableConnectable {
+
+    final Publisher source;
+
+    final int bufferSize;
+
+    final AtomicReference> current;
+
+    public FlowablePublishAlt(Publisher source, int bufferSize) {
+        this.source = source;
+        this.bufferSize = bufferSize;
+        this.current = new AtomicReference>();
+    }
+
+    @Override
+    public Publisher source() {
+        return source;
+    }
+
+    /**
+     * The internal buffer size of this FloawblePublishAlt operator.
+     * @return The internal buffer size of this FloawblePublishAlt operator.
+     */
+    public int publishBufferSize() {
+        return bufferSize;
+    }
+
+    @Override
+    public void connect(Consumer connection) {
+        PublishConnection conn;
+        boolean doConnect = false;
+
+        for (;;) {
+            conn = current.get();
+
+            if (conn == null || conn.isDisposed()) {
+                PublishConnection fresh = new PublishConnection(current, bufferSize);
+                if (!current.compareAndSet(conn, fresh)) {
+                    continue;
+                }
+                conn = fresh;
+            }
+
+            doConnect = !conn.connect.get() && conn.connect.compareAndSet(false, true);
+            break;
+        }
+
+        try {
+            connection.accept(conn);
+        } catch (Throwable ex) {
+            Exceptions.throwIfFatal(ex);
+            throw ExceptionHelper.wrapOrThrow(ex);
+        }
+
+        if (doConnect) {
+            source.subscribe(conn);
+        }
+    }
+
+    @Override
+    protected void subscribeActual(Subscriber s) {
+        PublishConnection conn;
+
+        for (;;) {
+            conn = current.get();
+
+            // don't create a fresh connection if the current is disposed
+            if (conn == null) {
+                PublishConnection fresh = new PublishConnection(current, bufferSize);
+                if (!current.compareAndSet(conn, fresh)) {
+                    continue;
+                }
+                conn = fresh;
+            }
+
+            break;
+        }
+
+        InnerSubscription inner = new InnerSubscription(s, conn);
+        s.onSubscribe(inner);
+
+        if (conn.add(inner)) {
+            if (inner.isCancelled()) {
+                conn.remove(inner);
+            } else {
+                conn.drain();
+            }
+            return;
+        }
+
+        Throwable ex = conn.error;
+        if (ex != null) {
+            s.onError(ex);
+        } else {
+            s.onComplete();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public void resetIf(Disposable connection) {
+        current.compareAndSet((PublishConnection)connection, null);
+    }
+
+    static final class PublishConnection
+    extends AtomicInteger
+    implements FlowableSubscriber, Disposable {
+
+        private static final long serialVersionUID = -1672047311619175801L;
+
+        final AtomicReference> current;
+
+        final AtomicReference upstream;
+
+        final AtomicBoolean connect;
+
+        final AtomicReference[]> subscribers;
+
+        final int bufferSize;
+
+        volatile SimpleQueue queue;
+
+        int sourceMode;
+
+        volatile boolean done;
+        Throwable error;
+
+        int consumed;
+
+        @SuppressWarnings("rawtypes")
+        static final InnerSubscription[] EMPTY = new InnerSubscription[0];
+        @SuppressWarnings("rawtypes")
+        static final InnerSubscription[] TERMINATED = new InnerSubscription[0];
+
+        @SuppressWarnings("unchecked")
+        PublishConnection(AtomicReference> current, int bufferSize) {
+            this.current = current;
+            this.upstream = new AtomicReference();
+            this.connect = new AtomicBoolean();
+            this.bufferSize = bufferSize;
+            this.subscribers = new AtomicReference[]>(EMPTY);
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public void dispose() {
+            subscribers.getAndSet(TERMINATED);
+            current.compareAndSet(this, null);
+            SubscriptionHelper.cancel(upstream);
+        }
+
+        @Override
+        public boolean isDisposed() {
+            return subscribers.get() == TERMINATED;
+        }
+
+        @Override
+        public void onSubscribe(Subscription s) {
+            if (SubscriptionHelper.setOnce(this.upstream, s)) {
+                if (s instanceof QueueSubscription) {
+                    @SuppressWarnings("unchecked")
+                    QueueSubscription qs = (QueueSubscription) s;
+
+                    int m = qs.requestFusion(QueueSubscription.ANY | QueueSubscription.BOUNDARY);
+                    if (m == QueueSubscription.SYNC) {
+                        sourceMode = m;
+                        queue = qs;
+                        done = true;
+                        drain();
+                        return;
+                    }
+                    if (m == QueueSubscription.ASYNC) {
+                        sourceMode = m;
+                        queue = qs;
+                        s.request(bufferSize);
+                        return;
+                    }
+                }
+
+                queue = new SpscArrayQueue(bufferSize);
+
+                s.request(bufferSize);
+            }
+        }
+
+        @Override
+        public void onNext(T t) {
+            // we expect upstream to honor backpressure requests
+            if (sourceMode == QueueSubscription.NONE && !queue.offer(t)) {
+                onError(new MissingBackpressureException("Prefetch queue is full?!"));
+                return;
+            }
+            // since many things can happen concurrently, we have a common dispatch
+            // loop to act on the current state serially
+            drain();
+        }
+
+        @Override
+        public void onError(Throwable t) {
+            if (done) {
+                RxJavaPlugins.onError(t);
+            } else {
+                error = t;
+                done = true;
+                drain();
+            }
+        }
+
+        @Override
+        public void onComplete() {
+            done = true;
+            drain();
+        }
+
+        void drain() {
+            if (getAndIncrement() != 0) {
+                return;
+            }
+
+            int missed = 1;
+            SimpleQueue queue = this.queue;
+            int consumed = this.consumed;
+            int limit = this.bufferSize - (this.bufferSize >> 2);
+            boolean async = this.sourceMode != QueueSubscription.SYNC;
+
+            outer:
+            for (;;) {
+                if (queue != null) {
+                    long minDemand = Long.MAX_VALUE;
+                    boolean hasDemand = false;
+
+                    InnerSubscription[] innerSubscriptions = subscribers.get();
+
+                    for (InnerSubscription inner : innerSubscriptions) {
+                        long request = inner.get();
+                        if (request != Long.MIN_VALUE) {
+                            hasDemand = true;
+                            minDemand = Math.min(request - inner.emitted, minDemand);
+                        }
+                    }
+
+                    if (!hasDemand) {
+                        minDemand = 0L;
+                    }
+
+                    while (minDemand != 0L) {
+                        boolean d = done;
+                        T v;
+
+                        try {
+                            v = queue.poll();
+                        } catch (Throwable ex) {
+                            Exceptions.throwIfFatal(ex);
+                            upstream.get().cancel();
+                            queue.clear();
+                            done = true;
+                            signalError(ex);
+                            return;
+                        }
+
+                        boolean empty = v == null;
+
+                        if (checkTerminated(d, empty)) {
+                            return;
+                        }
+
+                        if (empty) {
+                            break;
+                        }
+
+                        for (InnerSubscription inner : innerSubscriptions) {
+                            if (!inner.isCancelled()) {
+                                inner.downstream.onNext(v);
+                                inner.emitted++;
+                            }
+                        }
+
+                        if (async && ++consumed == limit) {
+                            consumed = 0;
+                            upstream.get().request(limit);
+                        }
+                        minDemand--;
+
+                        if (innerSubscriptions != subscribers.get()) {
+                            continue outer;
+                        }
+                    }
+
+                    if (checkTerminated(done, queue.isEmpty())) {
+                        return;
+                    }
+                }
+
+                this.consumed = consumed;
+                missed = addAndGet(-missed);
+                if (missed == 0) {
+                    break;
+                }
+                if (queue == null) {
+                    queue = this.queue;
+                }
+            }
+        }
+
+        @SuppressWarnings("unchecked")
+        boolean checkTerminated(boolean isDone, boolean isEmpty) {
+            if (isDone && isEmpty) {
+                Throwable ex = error;
+
+                if (ex != null) {
+                    signalError(ex);
+                } else {
+                    for (InnerSubscription inner : subscribers.getAndSet(TERMINATED)) {
+                        if (!inner.isCancelled()) {
+                            inner.downstream.onComplete();
+                        }
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+
+        @SuppressWarnings("unchecked")
+        void signalError(Throwable ex) {
+            for (InnerSubscription inner : subscribers.getAndSet(TERMINATED)) {
+                if (!inner.isCancelled()) {
+                    inner.downstream.onError(ex);
+                }
+            }
+        }
+
+        boolean add(InnerSubscription inner) {
+            // the state can change so we do a CAS loop to achieve atomicity
+            for (;;) {
+                // get the current producer array
+                InnerSubscription[] c = subscribers.get();
+                // if this subscriber-to-source reached a terminal state by receiving
+                // an onError or onComplete, just refuse to add the new producer
+                if (c == TERMINATED) {
+                    return false;
+                }
+                // we perform a copy-on-write logic
+                int len = c.length;
+                @SuppressWarnings("unchecked")
+                InnerSubscription[] u = new InnerSubscription[len + 1];
+                System.arraycopy(c, 0, u, 0, len);
+                u[len] = inner;
+                // try setting the subscribers array
+                if (subscribers.compareAndSet(c, u)) {
+                    return true;
+                }
+                // if failed, some other operation succeeded (another add, remove or termination)
+                // so retry
+            }
+        }
+
+        @SuppressWarnings("unchecked")
+        void remove(InnerSubscription inner) {
+            // the state can change so we do a CAS loop to achieve atomicity
+            for (;;) {
+                // let's read the current subscribers array
+                InnerSubscription[] c = subscribers.get();
+                int len = c.length;
+                // if it is either empty or terminated, there is nothing to remove so we quit
+                if (len == 0) {
+                    break;
+                }
+                // let's find the supplied producer in the array
+                // although this is O(n), we don't expect too many child subscribers in general
+                int j = -1;
+                for (int i = 0; i < len; i++) {
+                    if (c[i] == inner) {
+                        j = i;
+                        break;
+                    }
+                }
+                // we didn't find it so just quit
+                if (j < 0) {
+                    return;
+                }
+                // we do copy-on-write logic here
+                InnerSubscription[] u;
+                // we don't create a new empty array if producer was the single inhabitant
+                // but rather reuse an empty array
+                if (len == 1) {
+                    u = EMPTY;
+                } else {
+                    // otherwise, create a new array one less in size
+                    u = new InnerSubscription[len - 1];
+                    // copy elements being before the given producer
+                    System.arraycopy(c, 0, u, 0, j);
+                    // copy elements being after the given producer
+                    System.arraycopy(c, j + 1, u, j, len - j - 1);
+                }
+                // try setting this new array as
+                if (subscribers.compareAndSet(c, u)) {
+                    break;
+                }
+                // if we failed, it means something else happened
+                // (a concurrent add/remove or termination), we need to retry
+            }
+        }
+    }
+
+    static final class InnerSubscription extends AtomicLong
+    implements Subscription {
+
+        private static final long serialVersionUID = 2845000326761540265L;
+
+        final Subscriber downstream;
+
+        final PublishConnection parent;
+
+        long emitted;
+
+        InnerSubscription(Subscriber downstream, PublishConnection parent) {
+            this.downstream = downstream;
+            this.parent = parent;
+        }
+
+        @Override
+        public void request(long n) {
+            BackpressureHelper.addCancel(this, n);
+            parent.drain();
+        }
+
+        @Override
+        public void cancel() {
+            if (getAndSet(Long.MIN_VALUE) != Long.MIN_VALUE) {
+                parent.remove(this);
+                parent.drain();
+            }
+        }
+
+        public boolean isCancelled() {
+            return get() == Long.MIN_VALUE;
+        }
+    }
+}
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowablePublishClassic.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowablePublishClassic.java
new file mode 100644
index 0000000000..27ded26592
--- /dev/null
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowablePublishClassic.java
@@ -0,0 +1,43 @@
+/**
+ * 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.internal.operators.flowable;
+
+import org.reactivestreams.Publisher;
+
+/**
+ * Interface to mark classic publish() operators to
+ * indicate refCount() should replace them with the Alt
+ * implementation.
+ * 

+ * Without this, hooking the connectables with an intercept
+ * implementation would result in the unintended lack
+ * or presense of the replacement by refCount().
+ *
+ * @param  the element type of the sequence
+ * @since 2.2.10
+ */
+public interface FlowablePublishClassic {
+
+    /**
+     * The upstream source of this publish operator.
+     * @return the upstream source of this publish operator
+     */
+    Publisher publishSource();
+
+    /**
+     * The internal buffer size of this publish operator.
+     * @return the internal buffer size of this publish operator
+     */
+    int publishBufferSize();
+}
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableRefCount.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableRefCount.java
index bc11aa5425..2da1306632 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableRefCount.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableRefCount.java
@@ -25,7 +25,6 @@
 import io.reactivex.internal.disposables.*;
 import io.reactivex.internal.subscriptions.SubscriptionHelper;
 import io.reactivex.plugins.RxJavaPlugins;
-import io.reactivex.schedulers.Schedulers;
 
 /**
  * Returns an observable sequence that stays connected to the source as long as
@@ -49,7 +48,7 @@ public final class FlowableRefCount extends Flowable {
     RefConnection connection;
 
     public FlowableRefCount(ConnectableFlowable source) {
-        this(source, 1, 0L, TimeUnit.NANOSECONDS, Schedulers.trampoline());
+        this(source, 1, 0L, TimeUnit.NANOSECONDS, null);
     }
 
     public FlowableRefCount(ConnectableFlowable source, int n, long timeout, TimeUnit unit,
@@ -116,22 +115,42 @@ void cancel(RefConnection rc) {
 
     void terminated(RefConnection rc) {
         synchronized (this) {
-            if (connection != null && connection == rc) {
-                connection = null;
-                if (rc.timer != null) {
-                    rc.timer.dispose();
+            if (source instanceof FlowablePublishClassic) {
+                if (connection != null && connection == rc) {
+                    connection = null;
+                    clearTimer(rc);
                 }
-            }
-            if (--rc.subscriberCount == 0) {
-                if (source instanceof Disposable) {
-                    ((Disposable)source).dispose();
-                } else if (source instanceof ResettableConnectable) {
-                    ((ResettableConnectable)source).resetIf(rc.get());
+
+                if (--rc.subscriberCount == 0) {
+                    reset(rc);
+                }
+            } else {
+                if (connection != null && connection == rc) {
+                    clearTimer(rc);
+                    if (--rc.subscriberCount == 0) {
+                        connection = null;
+                        reset(rc);
+                    }
                 }
             }
         }
     }
 
+    void clearTimer(RefConnection rc) {
+        if (rc.timer != null) {
+            rc.timer.dispose();
+            rc.timer = null;
+        }
+    }
+
+    void reset(RefConnection rc) {
+        if (source instanceof Disposable) {
+            ((Disposable)source).dispose();
+        } else if (source instanceof ResettableConnectable) {
+            ((ResettableConnectable)source).resetIf(rc.get());
+        }
+    }
+
     void timeout(RefConnection rc) {
         synchronized (this) {
             if (rc.subscriberCount == 0 && rc == connection) {
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableReplay.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableReplay.java
index 21b1b1d39c..196596f1b2 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableReplay.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableReplay.java
@@ -566,6 +566,8 @@ public void dispose() {
                 // the others had non-zero. By removing this 'blocking' child, the others
                 // are now free to receive events
                 parent.manageRequests();
+                // make sure the last known node is not retained
+                index = null;
             }
         }
         /**
@@ -771,6 +773,11 @@ final void removeFirst() {
             }
 
             setFirst(head);
+            // correct the tail if all items have been removed
+            head = get();
+            if (head.get() == null) {
+                tail = head;
+            }
         }
         /**
          * Arranges the given node is the new head from now on.
@@ -824,6 +831,7 @@ public final void replay(InnerSubscription output) {
             }
             for (;;) {
                 if (output.isDisposed()) {
+                    output.index = null;
                     return;
                 }
 
@@ -864,6 +872,7 @@ public final void replay(InnerSubscription output) {
                         break;
                     }
                     if (output.isDisposed()) {
+                        output.index = null;
                         return;
                     }
                 }
@@ -1011,7 +1020,7 @@ void truncate() {
             int e = 0;
             for (;;) {
                 if (next != null) {
-                    if (size > limit) {
+                    if (size > limit && size > 1) { // never truncate the very last item just added
                         e++;
                         size--;
                         prev = next;
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableSamplePublisher.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableSamplePublisher.java
index 55439eee69..66b9c48ec3 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableSamplePublisher.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableSamplePublisher.java
@@ -90,7 +90,7 @@ public void onError(Throwable t) {
         @Override
         public void onComplete() {
             SubscriptionHelper.cancel(other);
-            completeMain();
+            completion();
         }
 
         void setOther(Subscription o) {
@@ -117,7 +117,7 @@ public void error(Throwable e) {
 
         public void complete() {
             upstream.cancel();
-            completeOther();
+            completion();
         }
 
         void emit() {
@@ -134,9 +134,7 @@ void emit() {
             }
         }
 
-        abstract void completeMain();
-
-        abstract void completeOther();
+        abstract void completion();
 
         abstract void run();
     }
@@ -178,12 +176,7 @@ static final class SampleMainNoLast extends SamplePublisherSubscriber {
         }
 
         @Override
-        void completeMain() {
-            downstream.onComplete();
-        }
-
-        @Override
-        void completeOther() {
+        void completion() {
             downstream.onComplete();
         }
 
@@ -207,16 +200,7 @@ static final class SampleMainEmitLast extends SamplePublisherSubscriber {
         }
 
         @Override
-        void completeMain() {
-            done = true;
-            if (wip.getAndIncrement() == 0) {
-                emit();
-                downstream.onComplete();
-            }
-        }
-
-        @Override
-        void completeOther() {
+        void completion() {
             done = true;
             if (wip.getAndIncrement() == 0) {
                 emit();
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableSwitchMap.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableSwitchMap.java
index 9730bd38b2..caf8c235c4 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableSwitchMap.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableSwitchMap.java
@@ -199,7 +199,6 @@ void drain() {
             for (;;) {
 
                 if (cancelled) {
-                    active.lazySet(null);
                     return;
                 }
 
@@ -314,7 +313,7 @@ void drain() {
                             if (r != Long.MAX_VALUE) {
                                 requested.addAndGet(-e);
                             }
-                            inner.get().request(e);
+                            inner.request(e);
                         }
                     }
 
@@ -398,6 +397,7 @@ public void onError(Throwable t) {
             if (index == p.unique && p.error.addThrowable(t)) {
                 if (!p.delayErrors) {
                     p.upstream.cancel();
+                    p.done = true;
                 }
                 done = true;
                 p.drain();
@@ -418,5 +418,11 @@ public void onComplete() {
         public void cancel() {
             SubscriptionHelper.cancel(this);
         }
+
+        public void request(long n) {
+            if (fusionMode != QueueSubscription.SYNC) {
+                get().request(n);
+            }
+        }
     }
 }
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableWindowBoundarySelector.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableWindowBoundarySelector.java
index 0e3fe58b83..d9d6ffa517 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableWindowBoundarySelector.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableWindowBoundarySelector.java
@@ -71,6 +71,8 @@ static final class WindowBoundaryMainSubscriber
 
         final AtomicLong windows = new AtomicLong();
 
+        final AtomicBoolean stopWindows = new AtomicBoolean();
+
         WindowBoundaryMainSubscriber(Subscriber> actual,
                 Publisher open, Function> close, int bufferSize) {
             super(actual, new MpscLinkedQueue());
@@ -89,14 +91,13 @@ public void onSubscribe(Subscription s) {
 
                 downstream.onSubscribe(this);
 
-                if (cancelled) {
+                if (stopWindows.get()) {
                     return;
                 }
 
                 OperatorWindowBoundaryOpenSubscriber os = new OperatorWindowBoundaryOpenSubscriber(this);
 
                 if (boundary.compareAndSet(null, os)) {
-                    windows.getAndIncrement();
                     s.request(Long.MAX_VALUE);
                     open.subscribe(os);
                 }
@@ -177,7 +178,12 @@ public void request(long n) {
 
         @Override
         public void cancel() {
-            cancelled = true;
+            if (stopWindows.compareAndSet(false, true)) {
+                DisposableHelper.dispose(boundary);
+                if (windows.decrementAndGet() == 0) {
+                    upstream.cancel();
+                }
+            }
         }
 
         void dispose() {
@@ -236,7 +242,7 @@ void drainLoop() {
                             continue;
                         }
 
-                        if (cancelled) {
+                        if (stopWindows.get()) {
                             continue;
                         }
 
@@ -250,7 +256,7 @@ void drainLoop() {
                                 produced(1);
                             }
                         } else {
-                            cancelled = true;
+                            cancel();
                             a.onError(new MissingBackpressureException("Could not deliver new window due to lack of requests"));
                             continue;
                         }
@@ -260,7 +266,7 @@ void drainLoop() {
                         try {
                             p = ObjectHelper.requireNonNull(close.apply(wo.open), "The publisher supplied is null");
                         } catch (Throwable e) {
-                            cancelled = true;
+                            cancel();
                             a.onError(e);
                             continue;
                         }
diff --git a/src/main/java/io/reactivex/internal/operators/flowable/FlowableWindowTimed.java b/src/main/java/io/reactivex/internal/operators/flowable/FlowableWindowTimed.java
index ae284ef27a..2db0eba8cc 100644
--- a/src/main/java/io/reactivex/internal/operators/flowable/FlowableWindowTimed.java
+++ b/src/main/java/io/reactivex/internal/operators/flowable/FlowableWindowTimed.java
@@ -160,7 +160,6 @@ public void onError(Throwable t) {
             }
 
             downstream.onError(t);
-            dispose();
         }
 
         @Override
@@ -171,7 +170,6 @@ public void onComplete() {
             }
 
             downstream.onComplete();
-            dispose();
         }
 
         @Override
@@ -184,22 +182,15 @@ public void cancel() {
             cancelled = true;
         }
 
-        public void dispose() {
-            DisposableHelper.dispose(timer);
-        }
-
         @Override
         public void run() {
-
             if (cancelled) {
                 terminated = true;
-                dispose();
             }
             queue.offer(NEXT);
             if (enter()) {
                 drainLoop();
             }
-
         }
 
         void drainLoop() {
@@ -221,13 +212,13 @@ void drainLoop() {
                     if (d && (o == null || o == NEXT)) {
                         window = null;
                         q.clear();
-                        dispose();
                         Throwable err = error;
                         if (err != null) {
                             w.onError(err);
                         } else {
                             w.onComplete();
                         }
+                        timer.dispose();
                         return;
                     }
 
@@ -251,8 +242,8 @@ void drainLoop() {
                                 window = null;
                                 queue.clear();
                                 upstream.cancel();
-                                dispose();
                                 a.onError(new MissingBackpressureException("Could not deliver first window due to lack of requests."));
+                                timer.dispose();
                                 return;
                             }
                         } else {
@@ -396,7 +387,7 @@ public void onNext(T t) {
                         window = null;
                         upstream.cancel();
                         downstream.onError(new MissingBackpressureException("Could not deliver window due to lack of requests"));
-                        dispose();
+                        disposeTimer();
                         return;
                     }
                 } else {
@@ -424,7 +415,6 @@ public void onError(Throwable t) {
             }
 
             downstream.onError(t);
-            dispose();
         }
 
         @Override
@@ -435,7 +425,6 @@ public void onComplete() {
             }
 
             downstream.onComplete();
-            dispose();
         }
 
         @Override
@@ -448,8 +437,8 @@ public void cancel() {
             cancelled = true;
         }
 
-        public void dispose() {
-            DisposableHelper.dispose(timer);
+        public void disposeTimer() {
+            timer.dispose();
             Worker w = worker;
             if (w != null) {
                 w.dispose();
@@ -468,7 +457,7 @@ void drainLoop() {
                     if (terminated) {
                         upstream.cancel();
                         q.clear();
-                        dispose();
+                        disposeTimer();
                         return;
                     }
 
@@ -488,7 +477,7 @@ void drainLoop() {
                         } else {
                             w.onComplete();
                         }
-                        dispose();
+                        disposeTimer();
                         return;
                     }
 
@@ -498,7 +487,7 @@ void drainLoop() {
 
                     if (isHolder) {
                         ConsumerIndexHolder consumerIndexHolder = (ConsumerIndexHolder) o;
-                        if (restartTimerOnMaxSize || producerIndex == consumerIndexHolder.index) {
+                        if (!restartTimerOnMaxSize || producerIndex == consumerIndexHolder.index) {
                             w.onComplete();
                             count = 0;
                             w = UnicastProcessor.create(bufferSize);
@@ -515,7 +504,7 @@ void drainLoop() {
                                 queue.clear();
                                 upstream.cancel();
                                 a.onError(new MissingBackpressureException("Could not deliver first window due to lack of requests."));
-                                dispose();
+                                disposeTimer();
                                 return;
                             }
                         }
@@ -554,7 +543,7 @@ void drainLoop() {
                             window = null;
                             upstream.cancel();
                             downstream.onError(new MissingBackpressureException("Could not deliver window due to lack of requests"));
-                            dispose();
+                            disposeTimer();
                             return;
                         }
                     } else {
@@ -585,7 +574,6 @@ public void run() {
                     p.queue.offer(this);
                 } else {
                     p.terminated = true;
-                    p.dispose();
                 }
                 if (p.enter()) {
                     p.drainLoop();
@@ -682,7 +670,6 @@ public void onError(Throwable t) {
             }
 
             downstream.onError(t);
-            dispose();
         }
 
         @Override
@@ -693,7 +680,6 @@ public void onComplete() {
             }
 
             downstream.onComplete();
-            dispose();
         }
 
         @Override
@@ -706,10 +692,6 @@ public void cancel() {
             cancelled = true;
         }
 
-        public void dispose() {
-            worker.dispose();
-        }
-
         void complete(UnicastProcessor w) {
             queue.offer(new SubjectWork(w, false));
             if (enter()) {
@@ -730,9 +712,9 @@ void drainLoop() {
                 for (;;) {
                     if (terminated) {
                         upstream.cancel();
-                        dispose();
                         q.clear();
                         ws.clear();
+                        worker.dispose();
                         return;
                     }
 
@@ -756,7 +738,7 @@ void drainLoop() {
                             }
                         }
                         ws.clear();
-                        dispose();
+                        worker.dispose();
                         return;
                     }
 
diff --git a/src/main/java/io/reactivex/internal/operators/maybe/MaybeAmb.java b/src/main/java/io/reactivex/internal/operators/maybe/MaybeAmb.java
index d9c1c6963c..8efc69b24b 100644
--- a/src/main/java/io/reactivex/internal/operators/maybe/MaybeAmb.java
+++ b/src/main/java/io/reactivex/internal/operators/maybe/MaybeAmb.java
@@ -64,64 +64,63 @@ protected void subscribeActual(MaybeObserver observer) {
             count = sources.length;
         }
 
-        AmbMaybeObserver parent = new AmbMaybeObserver(observer);
-        observer.onSubscribe(parent);
+        CompositeDisposable set = new CompositeDisposable();
+        observer.onSubscribe(set);
+
+        AtomicBoolean winner = new AtomicBoolean();
 
         for (int i = 0; i < count; i++) {
             MaybeSource s = sources[i];
-            if (parent.isDisposed()) {
+            if (set.isDisposed()) {
                 return;
             }
 
             if (s == null) {
-                parent.onError(new NullPointerException("One of the MaybeSources is null"));
+                set.dispose();
+                NullPointerException ex = new NullPointerException("One of the MaybeSources is null");
+                if (winner.compareAndSet(false, true)) {
+                    observer.onError(ex);
+                } else {
+                    RxJavaPlugins.onError(ex);
+                }
                 return;
             }
 
-            s.subscribe(parent);
+            s.subscribe(new AmbMaybeObserver(observer, set, winner));
         }
 
         if (count == 0) {
             observer.onComplete();
         }
-
     }
 
     static final class AmbMaybeObserver
-    extends AtomicBoolean
-    implements MaybeObserver, Disposable {
-
-        private static final long serialVersionUID = -7044685185359438206L;
+    implements MaybeObserver {
 
         final MaybeObserver downstream;
 
-        final CompositeDisposable set;
+        final AtomicBoolean winner;
 
-        AmbMaybeObserver(MaybeObserver downstream) {
-            this.downstream = downstream;
-            this.set = new CompositeDisposable();
-        }
+        final CompositeDisposable set;
 
-        @Override
-        public void dispose() {
-            if (compareAndSet(false, true)) {
-                set.dispose();
-            }
-        }
+        Disposable upstream;
 
-        @Override
-        public boolean isDisposed() {
-            return get();
+        AmbMaybeObserver(MaybeObserver downstream, CompositeDisposable set, AtomicBoolean winner) {
+            this.downstream = downstream;
+            this.set = set;
+            this.winner = winner;
         }
 
         @Override
         public void onSubscribe(Disposable d) {
+            upstream = d;
             set.add(d);
         }
 
         @Override
         public void onSuccess(T value) {
-            if (compareAndSet(false, true)) {
+            if (winner.compareAndSet(false, true)) {
+                set.delete(upstream);
                 set.dispose();
 
                 downstream.onSuccess(value);
@@ -130,7 +129,8 @@ public void onSuccess(T value) {
 
         @Override
         public void onError(Throwable e) {
-            if (compareAndSet(false, true)) {
+            if (winner.compareAndSet(false, true)) {
+                set.delete(upstream);
                 set.dispose();
 
                 downstream.onError(e);
@@ -141,12 +141,12 @@ public void onError(Throwable e) {
 
         @Override
         public void onComplete() {
-            if (compareAndSet(false, true)) {
+            if (winner.compareAndSet(false, true)) {
+                set.delete(upstream);
                 set.dispose();
 
                 downstream.onComplete();
             }
         }
-
     }
 }
diff --git a/src/main/java/io/reactivex/internal/operators/maybe/MaybeDoOnTerminate.java b/src/main/java/io/reactivex/internal/operators/maybe/MaybeDoOnTerminate.java
new file mode 100644
index 0000000000..81d0d8af34
--- /dev/null
+++ b/src/main/java/io/reactivex/internal/operators/maybe/MaybeDoOnTerminate.java
@@ -0,0 +1,90 @@
+/**
+ * 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.internal.operators.maybe;
+
+import io.reactivex.Maybe;
+import io.reactivex.MaybeObserver;
+import io.reactivex.MaybeSource;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.CompositeException;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Action;
+
+public final class MaybeDoOnTerminate extends Maybe {
+
+    final MaybeSource source;
+
+    final Action onTerminate;
+
+    public MaybeDoOnTerminate(MaybeSource source, Action onTerminate) {
+        this.source = source;
+        this.onTerminate = onTerminate;
+    }
+
+    @Override
+    protected void subscribeActual(MaybeObserver observer) {
+        source.subscribe(new DoOnTerminate(observer));
+    }
+
+    final class DoOnTerminate implements MaybeObserver {
+        final MaybeObserver downstream;
+
+        DoOnTerminate(MaybeObserver observer) {
+            this.downstream = observer;
+        }
+
+        @Override
+        public void onSubscribe(Disposable d) {
+            downstream.onSubscribe(d);
+        }
+
+        @Override
+        public void onSuccess(T value) {
+            try {
+                onTerminate.run();
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                downstream.onError(ex);
+                return;
+            }
+
+            downstream.onSuccess(value);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            try {
+                onTerminate.run();
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                e = new CompositeException(e, ex);
+            }
+
+            downstream.onError(e);
+        }
+
+        @Override
+        public void onComplete() {
+            try {
+                onTerminate.run();
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                downstream.onError(ex);
+                return;
+            }
+
+            downstream.onComplete();
+        }
+    }
+}
diff --git a/src/main/java/io/reactivex/internal/operators/observable/BlockingObservableIterable.java b/src/main/java/io/reactivex/internal/operators/observable/BlockingObservableIterable.java
index 3fdd26f9b6..24a7cb7701 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/BlockingObservableIterable.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/BlockingObservableIterable.java
@@ -53,7 +53,7 @@ static final class BlockingObservableIterator
         final Condition condition;
 
         volatile boolean done;
-        Throwable error;
+        volatile Throwable error;
 
         BlockingObservableIterator(int batchSize) {
             this.queue = new SpscLinkedArrayQueue(batchSize);
@@ -64,6 +64,13 @@ static final class BlockingObservableIterator
         @Override
         public boolean hasNext() {
             for (;;) {
+                if (isDisposed()) {
+                    Throwable e = error;
+                    if (e != null) {
+                        throw ExceptionHelper.wrapOrThrow(e);
+                    }
+                    return false;
+                }
                 boolean d = done;
                 boolean empty = queue.isEmpty();
                 if (d) {
@@ -80,7 +87,7 @@ public boolean hasNext() {
                         BlockingHelper.verifyNonBlocking();
                         lock.lock();
                         try {
-                            while (!done && queue.isEmpty()) {
+                            while (!done && queue.isEmpty() && !isDisposed()) {
                                 condition.await();
                             }
                         } finally {
@@ -146,6 +153,7 @@ public void remove() {
         @Override
         public void dispose() {
             DisposableHelper.dispose(this);
+            signalConsumer();
         }
 
         @Override
diff --git a/src/main/java/io/reactivex/internal/operators/observable/BlockingObservableMostRecent.java b/src/main/java/io/reactivex/internal/operators/observable/BlockingObservableMostRecent.java
index 90a603f65c..04940be5e6 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/BlockingObservableMostRecent.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/BlockingObservableMostRecent.java
@@ -42,10 +42,6 @@ public BlockingObservableMostRecent(ObservableSource source, T initialValue)
     public Iterator iterator() {
         MostRecentObserver mostRecentObserver = new MostRecentObserver(initialValue);
 
-        /**
-         * Subscribe instead of unsafeSubscribe since this is the final subscribe in the chain
-         * since it is for BlockingObservable.
-         */
         source.subscribe(mostRecentObserver);
 
         return mostRecentObserver.getIterable();
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableAmb.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableAmb.java
index 2ed4fcd93b..53068e7a91 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableAmb.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableAmb.java
@@ -36,7 +36,7 @@ public void subscribeActual(Observer observer) {
         ObservableSource[] sources = this.sources;
         int count = 0;
         if (sources == null) {
-            sources = new Observable[8];
+            sources = new ObservableSource[8];
             try {
                 for (ObservableSource p : sourcesIterable) {
                     if (p == null) {
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableBlockingSubscribe.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableBlockingSubscribe.java
index 4373a321aa..589b71c5f9 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableBlockingSubscribe.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableBlockingSubscribe.java
@@ -61,7 +61,7 @@ public static  void subscribe(ObservableSource o, Observer observer) {
         ObservableSource[] sources = this.sources;
         int count = 0;
         if (sources == null) {
-            sources = new Observable[8];
+            sources = new ObservableSource[8];
             for (ObservableSource p : sourcesIterable) {
                 if (count == sources.length) {
                     ObservableSource[] b = new ObservableSource[count + (count >> 2)];
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableConcatMapEager.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableConcatMapEager.java
index cb15b10f65..7028fdcf62 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableConcatMapEager.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableConcatMapEager.java
@@ -162,10 +162,21 @@ public void onComplete() {
 
         @Override
         public void dispose() {
+            if (cancelled) {
+                return;
+            }
             cancelled = true;
+            upstream.dispose();
+
+            drainAndDispose();
+        }
+
+        void drainAndDispose() {
             if (getAndIncrement() == 0) {
-                queue.clear();
-                disposeAll();
+                do {
+                    queue.clear();
+                    disposeAll();
+                } while (decrementAndGet() != 0);
             }
         }
 
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableDebounce.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableDebounce.java
index 2c056eb70e..db8b9d4794 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableDebounce.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableDebounce.java
@@ -112,7 +112,9 @@ public void onComplete() {
             if (d != DisposableHelper.DISPOSED) {
                 @SuppressWarnings("unchecked")
                 DebounceInnerObserver dis = (DebounceInnerObserver)d;
-                dis.emit();
+                if (dis != null) {
+                    dis.emit();
+                }
                 DisposableHelper.dispose(debouncer);
                 downstream.onComplete();
             }
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableFlatMap.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableFlatMap.java
index a4766f389d..73a5306513 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableFlatMap.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableFlatMap.java
@@ -334,6 +334,7 @@ void drainLoop() {
                 if (checkTerminate()) {
                     return;
                 }
+                int innerCompleted = 0;
                 SimplePlainQueue svq = queue;
 
                 if (svq != null) {
@@ -349,9 +350,18 @@ void drainLoop() {
                         }
 
                         child.onNext(o);
+                        innerCompleted++;
                     }
                 }
 
+                if (innerCompleted != 0) {
+                    if (maxConcurrency != Integer.MAX_VALUE) {
+                        subscribeMore(innerCompleted);
+                        innerCompleted = 0;
+                    }
+                    continue;
+                }
+
                 boolean d = done;
                 svq = queue;
                 InnerObserver[] inner = observers.get();
@@ -376,7 +386,6 @@ void drainLoop() {
                     return;
                 }
 
-                int innerCompleted = 0;
                 if (n != 0) {
                     long startId = lastId;
                     int index = lastIndex;
@@ -463,20 +472,12 @@ void drainLoop() {
 
                 if (innerCompleted != 0) {
                     if (maxConcurrency != Integer.MAX_VALUE) {
-                        while (innerCompleted-- != 0) {
-                            ObservableSource p;
-                            synchronized (this) {
-                                p = sources.poll();
-                                if (p == null) {
-                                    wip--;
-                                    continue;
-                                }
-                            }
-                            subscribeInner(p);
-                        }
+                        subscribeMore(innerCompleted);
+                        innerCompleted = 0;
                     }
                     continue;
                 }
+
                 missed = addAndGet(-missed);
                 if (missed == 0) {
                     break;
@@ -484,6 +485,20 @@ void drainLoop() {
             }
         }
 
+        void subscribeMore(int innerCompleted) {
+            while (innerCompleted-- != 0) {
+                ObservableSource p;
+                synchronized (this) {
+                    p = sources.poll();
+                    if (p == null) {
+                        wip--;
+                        continue;
+                    }
+                }
+                subscribeInner(p);
+            }
+        }
+
         boolean checkTerminate() {
             if (cancelled) {
                 return true;
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableFromArray.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableFromArray.java
index 11b871ee46..9a04a4fcc3 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableFromArray.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableFromArray.java
@@ -102,7 +102,7 @@ void run() {
             for (int i = 0; i < n && !isDisposed(); i++) {
                 T value = a[i];
                 if (value == null) {
-                    downstream.onError(new NullPointerException("The " + i + "th element is null"));
+                    downstream.onError(new NullPointerException("The element at index " + i + " is null"));
                     return;
                 }
                 downstream.onNext(value);
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableMergeWithCompletable.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableMergeWithCompletable.java
index fa020b6ae4..3b9e649062 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableMergeWithCompletable.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableMergeWithCompletable.java
@@ -80,7 +80,7 @@ public void onNext(T t) {
 
         @Override
         public void onError(Throwable ex) {
-            DisposableHelper.dispose(mainDisposable);
+            DisposableHelper.dispose(otherObserver);
             HalfSerializer.onError(downstream, ex, this, error);
         }
 
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableMergeWithMaybe.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableMergeWithMaybe.java
index 23b2532d9b..e7caad3b21 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableMergeWithMaybe.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableMergeWithMaybe.java
@@ -106,7 +106,7 @@ public void onNext(T t) {
         @Override
         public void onError(Throwable ex) {
             if (error.addThrowable(ex)) {
-                DisposableHelper.dispose(mainDisposable);
+                DisposableHelper.dispose(otherObserver);
                 drain();
             } else {
                 RxJavaPlugins.onError(ex);
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableMergeWithSingle.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableMergeWithSingle.java
index 20c4d21b5c..7332a29a25 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableMergeWithSingle.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableMergeWithSingle.java
@@ -106,7 +106,7 @@ public void onNext(T t) {
         @Override
         public void onError(Throwable ex) {
             if (error.addThrowable(ex)) {
-                DisposableHelper.dispose(mainDisposable);
+                DisposableHelper.dispose(otherObserver);
                 drain();
             } else {
                 RxJavaPlugins.onError(ex);
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableObserveOn.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableObserveOn.java
index abf1f0bb85..56de30041e 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableObserveOn.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableObserveOn.java
@@ -145,7 +145,7 @@ public void dispose() {
                 disposed = true;
                 upstream.dispose();
                 worker.dispose();
-                if (getAndIncrement() == 0) {
+                if (!outputFused && getAndIncrement() == 0) {
                     queue.clear();
                 }
             }
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservablePublish.java b/src/main/java/io/reactivex/internal/operators/observable/ObservablePublish.java
index debc37875b..04b90506c3 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservablePublish.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservablePublish.java
@@ -30,7 +30,8 @@
  * manner.
  * @param  the value type
  */
-public final class ObservablePublish extends ConnectableObservable implements HasUpstreamObservableSource {
+public final class ObservablePublish extends ConnectableObservable
+implements HasUpstreamObservableSource, ObservablePublishClassic {
     /** The source observable. */
     final ObservableSource source;
     /** Holds the current subscriber that is, will be or just was subscribed to the source observable. */
@@ -63,6 +64,11 @@ public ObservableSource source() {
         return source;
     }
 
+    @Override
+    public ObservableSource publishSource() {
+        return source;
+    }
+
     @Override
     protected void subscribeActual(Observer observer) {
         onSubscribe.subscribe(observer);
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservablePublishAlt.java b/src/main/java/io/reactivex/internal/operators/observable/ObservablePublishAlt.java
new file mode 100644
index 0000000000..a9e62babde
--- /dev/null
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservablePublishAlt.java
@@ -0,0 +1,282 @@
+/**
+ * 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.internal.operators.observable;
+
+import java.util.concurrent.atomic.*;
+
+import io.reactivex.*;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Consumer;
+import io.reactivex.internal.disposables.*;
+import io.reactivex.internal.fuseable.HasUpstreamObservableSource;
+import io.reactivex.internal.util.ExceptionHelper;
+import io.reactivex.observables.ConnectableObservable;
+
+/**
+ * Shares a single underlying connection to the upstream ObservableSource
+ * and multicasts events to all subscribed observers until the upstream
+ * completes or the connection is disposed.
+ * 

+ * The difference to ObservablePublish is that when the upstream terminates,
+ * late observers will receive that terminal event until the connection is
+ * disposed and the ConnectableObservable is reset to its fresh state.
+ *
+ * @param  the element type
+ * @since 2.2.10
+ */
+public final class ObservablePublishAlt extends ConnectableObservable
+implements HasUpstreamObservableSource, ResettableConnectable {
+
+    final ObservableSource source;
+
+    final AtomicReference> current;
+
+    public ObservablePublishAlt(ObservableSource source) {
+        this.source = source;
+        this.current = new AtomicReference>();
+    }
+
+    @Override
+    public void connect(Consumer connection) {
+        boolean doConnect = false;
+        PublishConnection conn;
+
+        for (;;) {
+            conn = current.get();
+
+            if (conn == null || conn.isDisposed()) {
+                PublishConnection fresh = new PublishConnection(current);
+                if (!current.compareAndSet(conn, fresh)) {
+                    continue;
+                }
+                conn = fresh;
+            }
+
+            doConnect = !conn.connect.get() && conn.connect.compareAndSet(false, true);
+            break;
+        }
+
+        try {
+            connection.accept(conn);
+        } catch (Throwable ex) {
+            Exceptions.throwIfFatal(ex);
+            throw ExceptionHelper.wrapOrThrow(ex);
+        }
+
+        if (doConnect) {
+            source.subscribe(conn);
+        }
+    }
+
+    @Override
+    protected void subscribeActual(Observer observer) {
+        PublishConnection conn;
+
+        for (;;) {
+            conn = current.get();
+            // we don't create a fresh connection if the current is terminated
+            if (conn == null) {
+                PublishConnection fresh = new PublishConnection(current);
+                if (!current.compareAndSet(conn, fresh)) {
+                    continue;
+                }
+                conn = fresh;
+            }
+            break;
+        }
+
+        InnerDisposable inner = new InnerDisposable(observer, conn);
+        observer.onSubscribe(inner);
+        if (conn.add(inner)) {
+            if (inner.isDisposed()) {
+                conn.remove(inner);
+            }
+            return;
+        }
+        // Late observers will be simply terminated
+        Throwable error = conn.error;
+        if (error != null) {
+            observer.onError(error);
+        } else {
+            observer.onComplete();
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void resetIf(Disposable connection) {
+        current.compareAndSet((PublishConnection)connection, null);
+    }
+
+    @Override
+    public ObservableSource source() {
+        return source;
+    }
+
+    static final class PublishConnection
+    extends AtomicReference[]>
+    implements Observer, Disposable {
+
+        private static final long serialVersionUID = -3251430252873581268L;
+
+        final AtomicBoolean connect;
+
+        final AtomicReference> current;
+
+        final AtomicReference upstream;
+
+        @SuppressWarnings("rawtypes")
+        static final InnerDisposable[] EMPTY = new InnerDisposable[0];
+
+        @SuppressWarnings("rawtypes")
+        static final InnerDisposable[] TERMINATED = new InnerDisposable[0];
+
+        Throwable error;
+
+        @SuppressWarnings("unchecked")
+        PublishConnection(AtomicReference> current) {
+            this.connect = new AtomicBoolean();
+            this.current = current;
+            this.upstream = new AtomicReference();
+            lazySet(EMPTY);
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public void dispose() {
+            getAndSet(TERMINATED);
+            current.compareAndSet(this, null);
+            DisposableHelper.dispose(upstream);
+        }
+
+        @Override
+        public boolean isDisposed() {
+            return get() == TERMINATED;
+        }
+
+        @Override
+        public void onSubscribe(Disposable d) {
+            DisposableHelper.setOnce(upstream, d);
+        }
+
+        @Override
+        public void onNext(T t) {
+            for (InnerDisposable inner : get()) {
+                inner.downstream.onNext(t);
+            }
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public void onError(Throwable e) {
+            error = e;
+            upstream.lazySet(DisposableHelper.DISPOSED);
+            for (InnerDisposable inner : getAndSet(TERMINATED)) {
+                inner.downstream.onError(e);
+            }
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public void onComplete() {
+            upstream.lazySet(DisposableHelper.DISPOSED);
+            for (InnerDisposable inner : getAndSet(TERMINATED)) {
+                inner.downstream.onComplete();
+            }
+        }
+
+        public boolean add(InnerDisposable inner) {
+            for (;;) {
+                InnerDisposable[] a = get();
+                if (a == TERMINATED) {
+                    return false;
+                }
+                int n = a.length;
+                @SuppressWarnings("unchecked")
+                InnerDisposable[] b = new InnerDisposable[n + 1];
+                System.arraycopy(a, 0, b, 0, n);
+                b[n] = inner;
+                if (compareAndSet(a, b)) {
+                    return true;
+                }
+            }
+        }
+
+        @SuppressWarnings("unchecked")
+        public void remove(InnerDisposable inner) {
+            for (;;) {
+                InnerDisposable[] a = get();
+                int n = a.length;
+                if (n == 0) {
+                    return;
+                }
+
+                int j = -1;
+                for (int i = 0; i < n; i++) {
+                    if (a[i] == inner) {
+                        j = i;
+                        break;
+                    }
+                }
+
+                if (j < 0) {
+                    return;
+                }
+                InnerDisposable[] b = EMPTY;
+                if (n != 1) {
+                    b = new InnerDisposable[n - 1];
+                    System.arraycopy(a, 0, b, 0, j);
+                    System.arraycopy(a, j + 1, b, j, n - j - 1);
+                }
+                if (compareAndSet(a, b)) {
+                    return;
+                }
+            }
+        }
+    }
+
+    /**
+     * Intercepts the dispose signal from the downstream and
+     * removes itself from the connection's observers array
+     * at most once.
+     * @param  the element type
+     */
+    static final class InnerDisposable
+    extends AtomicReference>
+    implements Disposable {
+
+        private static final long serialVersionUID = 7463222674719692880L;
+
+        final Observer downstream;
+
+        InnerDisposable(Observer downstream, PublishConnection parent) {
+            this.downstream = downstream;
+            lazySet(parent);
+        }
+
+        @Override
+        public void dispose() {
+            PublishConnection p = getAndSet(null);
+            if (p != null) {
+                p.remove(this);
+            }
+        }
+
+        @Override
+        public boolean isDisposed() {
+            return get() == null;
+        }
+    }
+}
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservablePublishClassic.java b/src/main/java/io/reactivex/internal/operators/observable/ObservablePublishClassic.java
new file mode 100644
index 0000000000..b2bfe87f71
--- /dev/null
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservablePublishClassic.java
@@ -0,0 +1,37 @@
+/**
+ * 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.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+
+/**
+ * Interface to mark classic publish() operators to
+ * indicate refCount() should replace them with the Alt
+ * implementation.
+ * 

+ * Without this, hooking the connectables with an intercept
+ * implementation would result in the unintended lack
+ * or presense of the replacement by refCount().
+ *
+ * @param  the element type of the sequence
+ * @since 2.2.10
+ */
+public interface ObservablePublishClassic {
+
+    /**
+     * The upstream source of this publish operator.
+     * @return the upstream source of this publish operator
+     */
+    ObservableSource publishSource();
+}
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableRefCount.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableRefCount.java
index 5abc174350..27e633c664 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableRefCount.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableRefCount.java
@@ -22,7 +22,6 @@
 import io.reactivex.internal.disposables.*;
 import io.reactivex.observables.ConnectableObservable;
 import io.reactivex.plugins.RxJavaPlugins;
-import io.reactivex.schedulers.Schedulers;
 
 /**
  * Returns an observable sequence that stays connected to the source as long as
@@ -46,7 +45,7 @@ public final class ObservableRefCount extends Observable {
     RefConnection connection;
 
     public ObservableRefCount(ConnectableObservable source) {
-        this(source, 1, 0L, TimeUnit.NANOSECONDS, Schedulers.trampoline());
+        this(source, 1, 0L, TimeUnit.NANOSECONDS, null);
     }
 
     public ObservableRefCount(ConnectableObservable source, int n, long timeout, TimeUnit unit,
@@ -113,22 +112,42 @@ void cancel(RefConnection rc) {
 
     void terminated(RefConnection rc) {
         synchronized (this) {
-            if (connection != null && connection == rc) {
-                connection = null;
-                if (rc.timer != null) {
-                    rc.timer.dispose();
+            if (source instanceof ObservablePublishClassic) {
+                if (connection != null && connection == rc) {
+                    connection = null;
+                    clearTimer(rc);
                 }
-            }
-            if (--rc.subscriberCount == 0) {
-                if (source instanceof Disposable) {
-                    ((Disposable)source).dispose();
-                } else if (source instanceof ResettableConnectable) {
-                    ((ResettableConnectable)source).resetIf(rc.get());
+
+                if (--rc.subscriberCount == 0) {
+                    reset(rc);
+                }
+            } else {
+                if (connection != null && connection == rc) {
+                    clearTimer(rc);
+                    if (--rc.subscriberCount == 0) {
+                        connection = null;
+                        reset(rc);
+                    }
                 }
             }
         }
     }
 
+    void clearTimer(RefConnection rc) {
+        if (rc.timer != null) {
+            rc.timer.dispose();
+            rc.timer = null;
+        }
+    }
+
+    void reset(RefConnection rc) {
+        if (source instanceof Disposable) {
+            ((Disposable)source).dispose();
+        } else if (source instanceof ResettableConnectable) {
+            ((ResettableConnectable)source).resetIf(rc.get());
+        }
+    }
+
     void timeout(RefConnection rc) {
         synchronized (this) {
             if (rc.subscriberCount == 0 && rc == connection) {
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableRepeatWhen.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableRepeatWhen.java
index af27f2f6d0..24725997d1 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableRepeatWhen.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableRepeatWhen.java
@@ -108,8 +108,8 @@ public void onError(Throwable e) {
 
         @Override
         public void onComplete() {
-            active = false;
             DisposableHelper.replace(upstream, null);
+            active = false;
             signaller.onNext(0);
         }
 
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableReplay.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableReplay.java
index 89db184d6b..2818d975f1 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableReplay.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableReplay.java
@@ -453,6 +453,8 @@ public void dispose() {
                 cancelled = true;
                 // remove this from the parent
                 parent.remove(this);
+                // make sure the last known node is not retained
+                index = null;
             }
         }
         /**
@@ -636,6 +638,11 @@ final void trimHead() {
             }
 
             setFirst(head);
+            // correct the tail if all items have been removed
+            head = get();
+            if (head.get() == null) {
+                tail = head;
+            }
         }
         /**
          * Arranges the given node is the new head from now on.
@@ -686,6 +693,7 @@ public final void replay(InnerDisposable output) {
 
                 for (;;) {
                     if (output.isDisposed()) {
+                        output.index = null;
                         return;
                     }
 
@@ -836,7 +844,7 @@ void truncate() {
             int e = 0;
             for (;;) {
                 if (next != null) {
-                    if (size > limit) {
+                    if (size > limit && size > 1) { // never truncate the very last item just added
                         e++;
                         size--;
                         prev = next;
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableSampleWithObservable.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableSampleWithObservable.java
index fcb0f33a00..1d5f8a5fe1 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableSampleWithObservable.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableSampleWithObservable.java
@@ -84,7 +84,7 @@ public void onError(Throwable t) {
         @Override
         public void onComplete() {
             DisposableHelper.dispose(other);
-            completeMain();
+            completion();
         }
 
         boolean setOther(Disposable o) {
@@ -109,7 +109,7 @@ public void error(Throwable e) {
 
         public void complete() {
             upstream.dispose();
-            completeOther();
+            completion();
         }
 
         void emit() {
@@ -119,9 +119,7 @@ void emit() {
             }
         }
 
-        abstract void completeMain();
-
-        abstract void completeOther();
+        abstract void completion();
 
         abstract void run();
     }
@@ -163,12 +161,7 @@ static final class SampleMainNoLast extends SampleMainObserver {
         }
 
         @Override
-        void completeMain() {
-            downstream.onComplete();
-        }
-
-        @Override
-        void completeOther() {
+        void completion() {
             downstream.onComplete();
         }
 
@@ -192,16 +185,7 @@ static final class SampleMainEmitLast extends SampleMainObserver {
         }
 
         @Override
-        void completeMain() {
-            done = true;
-            if (wip.getAndIncrement() == 0) {
-                emit();
-                downstream.onComplete();
-            }
-        }
-
-        @Override
-        void completeOther() {
+        void completion() {
             done = true;
             if (wip.getAndIncrement() == 0) {
                 emit();
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableSwitchMap.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableSwitchMap.java
index 8c5aa371dc..4e97ea405d 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableSwitchMap.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableSwitchMap.java
@@ -314,6 +314,7 @@ void innerError(SwitchMapInnerObserver inner, Throwable ex) {
             if (inner.index == unique && errors.addThrowable(ex)) {
                 if (!delayErrors) {
                     upstream.dispose();
+                    done = true;
                 }
                 inner.done = true;
                 drain();
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableTakeLastTimed.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableTakeLastTimed.java
index 7bd29092b4..213588032b 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableTakeLastTimed.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableTakeLastTimed.java
@@ -139,6 +139,7 @@ void drain() {
             final Observer a = downstream;
             final SpscLinkedArrayQueue q = queue;
             final boolean delayError = this.delayError;
+            final long timestampLimit = scheduler.now(unit) - time;
 
             for (;;) {
                 if (cancelled) {
@@ -171,7 +172,7 @@ void drain() {
                 @SuppressWarnings("unchecked")
                 T o = (T)q.poll();
 
-                if ((Long)ts < scheduler.now(unit) - time) {
+                if ((Long)ts < timestampLimit) {
                     continue;
                 }
 
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableWindowBoundarySelector.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableWindowBoundarySelector.java
index 1e2a2ea052..d8e745e213 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableWindowBoundarySelector.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableWindowBoundarySelector.java
@@ -69,6 +69,8 @@ static final class WindowBoundaryMainObserver
 
         final AtomicLong windows = new AtomicLong();
 
+        final AtomicBoolean stopWindows = new AtomicBoolean();
+
         WindowBoundaryMainObserver(Observer> actual,
                                             ObservableSource open, Function> close, int bufferSize) {
             super(actual, new MpscLinkedQueue());
@@ -87,14 +89,13 @@ public void onSubscribe(Disposable d) {
 
                 downstream.onSubscribe(this);
 
-                if (cancelled) {
+                if (stopWindows.get()) {
                     return;
                 }
 
                 OperatorWindowBoundaryOpenObserver os = new OperatorWindowBoundaryOpenObserver(this);
 
                 if (boundary.compareAndSet(null, os)) {
-                    windows.getAndIncrement();
                     open.subscribe(os);
                 }
             }
@@ -164,12 +165,17 @@ void error(Throwable t) {
 
         @Override
         public void dispose() {
-            cancelled = true;
+            if (stopWindows.compareAndSet(false, true)) {
+                DisposableHelper.dispose(boundary);
+                if (windows.decrementAndGet() == 0) {
+                    upstream.dispose();
+                }
+            }
         }
 
         @Override
         public boolean isDisposed() {
-            return cancelled;
+            return stopWindows.get();
         }
 
         void disposeBoundary() {
@@ -229,7 +235,7 @@ void drainLoop() {
                             continue;
                         }
 
-                        if (cancelled) {
+                        if (stopWindows.get()) {
                             continue;
                         }
 
@@ -244,7 +250,7 @@ void drainLoop() {
                             p = ObjectHelper.requireNonNull(close.apply(wo.open), "The ObservableSource supplied is null");
                         } catch (Throwable e) {
                             Exceptions.throwIfFatal(e);
-                            cancelled = true;
+                            stopWindows.set(true);
                             a.onError(e);
                             continue;
                         }
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableWindowTimed.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableWindowTimed.java
index 1ffc0f475e..5214d2b225 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableWindowTimed.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableWindowTimed.java
@@ -15,14 +15,13 @@
 
 import java.util.*;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
 
 import io.reactivex.*;
 import io.reactivex.Observable;
 import io.reactivex.Observer;
 import io.reactivex.Scheduler.Worker;
 import io.reactivex.disposables.Disposable;
-import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.disposables.*;
 import io.reactivex.internal.observers.QueueDrainObserver;
 import io.reactivex.internal.queue.MpscLinkedQueue;
 import io.reactivex.internal.util.NotificationLite;
@@ -85,7 +84,7 @@ static final class WindowExactUnboundedObserver
 
         UnicastSubject window;
 
-        final AtomicReference timer = new AtomicReference();
+        final SequentialDisposable timer = new SequentialDisposable();
 
         static final Object NEXT = new Object();
 
@@ -114,7 +113,7 @@ public void onSubscribe(Disposable d) {
 
                 if (!cancelled) {
                     Disposable task = scheduler.schedulePeriodicallyDirect(this, timespan, timespan, unit);
-                    DisposableHelper.replace(timer, task);
+                    timer.replace(task);
                 }
             }
         }
@@ -146,7 +145,6 @@ public void onError(Throwable t) {
                 drainLoop();
             }
 
-            disposeTimer();
             downstream.onError(t);
         }
 
@@ -157,7 +155,6 @@ public void onComplete() {
                 drainLoop();
             }
 
-            disposeTimer();
             downstream.onComplete();
         }
 
@@ -171,15 +168,10 @@ public boolean isDisposed() {
             return cancelled;
         }
 
-        void disposeTimer() {
-            DisposableHelper.dispose(timer);
-        }
-
         @Override
         public void run() {
             if (cancelled) {
                 terminated = true;
-                disposeTimer();
             }
             queue.offer(NEXT);
             if (enter()) {
@@ -206,13 +198,13 @@ void drainLoop() {
                     if (d && (o == null || o == NEXT)) {
                         window = null;
                         q.clear();
-                        disposeTimer();
                         Throwable err = error;
                         if (err != null) {
                             w.onError(err);
                         } else {
                             w.onComplete();
                         }
+                        timer.dispose();
                         return;
                     }
 
@@ -266,7 +258,7 @@ static final class WindowExactBoundedObserver
 
         volatile boolean terminated;
 
-        final AtomicReference timer = new AtomicReference();
+        final SequentialDisposable timer = new SequentialDisposable();
 
         WindowExactBoundedObserver(
                 Observer> actual,
@@ -312,7 +304,7 @@ public void onSubscribe(Disposable d) {
                     task = scheduler.schedulePeriodicallyDirect(consumerIndexHolder, timespan, timespan, unit);
                 }
 
-                DisposableHelper.replace(timer, task);
+                timer.replace(task);
             }
         }
 
@@ -370,7 +362,6 @@ public void onError(Throwable t) {
             }
 
             downstream.onError(t);
-            disposeTimer();
         }
 
         @Override
@@ -381,7 +372,6 @@ public void onComplete() {
             }
 
             downstream.onComplete();
-            disposeTimer();
         }
 
         @Override
@@ -428,13 +418,13 @@ void drainLoop() {
                     if (d && (empty || isHolder)) {
                         window = null;
                         q.clear();
-                        disposeTimer();
                         Throwable err = error;
                         if (err != null) {
                             w.onError(err);
                         } else {
                             w.onComplete();
                         }
+                        disposeTimer();
                         return;
                     }
 
@@ -444,7 +434,7 @@ void drainLoop() {
 
                     if (isHolder) {
                         ConsumerIndexHolder consumerIndexHolder = (ConsumerIndexHolder) o;
-                        if (restartTimerOnMaxSize || producerIndex == consumerIndexHolder.index) {
+                        if (!restartTimerOnMaxSize || producerIndex == consumerIndexHolder.index) {
                             w.onComplete();
                             count = 0;
                             w = UnicastSubject.create(bufferSize);
@@ -507,7 +497,6 @@ public void run() {
                     p.queue.offer(this);
                 } else {
                     p.terminated = true;
-                    p.disposeTimer();
                 }
                 if (p.enter()) {
                     p.drainLoop();
@@ -592,7 +581,6 @@ public void onError(Throwable t) {
             }
 
             downstream.onError(t);
-            disposeWorker();
         }
 
         @Override
@@ -603,7 +591,6 @@ public void onComplete() {
             }
 
             downstream.onComplete();
-            disposeWorker();
         }
 
         @Override
@@ -616,10 +603,6 @@ public boolean isDisposed() {
             return cancelled;
         }
 
-        void disposeWorker() {
-            worker.dispose();
-        }
-
         void complete(UnicastSubject w) {
             queue.offer(new SubjectWork(w, false));
             if (enter()) {
@@ -640,9 +623,9 @@ void drainLoop() {
                 for (;;) {
                     if (terminated) {
                         upstream.dispose();
-                        disposeWorker();
                         q.clear();
                         ws.clear();
+                        worker.dispose();
                         return;
                     }
 
@@ -665,8 +648,8 @@ void drainLoop() {
                                 w.onComplete();
                             }
                         }
-                        disposeWorker();
                         ws.clear();
+                        worker.dispose();
                         return;
                     }
 
diff --git a/src/main/java/io/reactivex/internal/operators/observable/ObservableZip.java b/src/main/java/io/reactivex/internal/operators/observable/ObservableZip.java
index a259cd6d56..7f00383834 100644
--- a/src/main/java/io/reactivex/internal/operators/observable/ObservableZip.java
+++ b/src/main/java/io/reactivex/internal/operators/observable/ObservableZip.java
@@ -50,7 +50,7 @@ public void subscribeActual(Observer observer) {
         ObservableSource[] sources = this.sources;
         int count = 0;
         if (sources == null) {
-            sources = new Observable[8];
+            sources = new ObservableSource[8];
             for (ObservableSource p : sourcesIterable) {
                 if (count == sources.length) {
                     ObservableSource[] b = new ObservableSource[count + (count >> 2)];
@@ -179,6 +179,7 @@ public void drain() {
                             if (z.done && !delayError) {
                                 Throwable ex = z.error;
                                 if (ex != null) {
+                                    cancelled = true;
                                     cancel();
                                     a.onError(ex);
                                     return;
@@ -224,6 +225,7 @@ boolean checkTerminated(boolean d, boolean empty, Observer a, boolean
                 if (delayError) {
                     if (empty) {
                         Throwable e = source.error;
+                        cancelled = true;
                         cancel();
                         if (e != null) {
                             a.onError(e);
@@ -235,11 +237,13 @@ boolean checkTerminated(boolean d, boolean empty, Observer a, boolean
                 } else {
                     Throwable e = source.error;
                     if (e != null) {
+                        cancelled = true;
                         cancel();
                         a.onError(e);
                         return true;
                     } else
                     if (empty) {
+                        cancelled = true;
                         cancel();
                         a.onComplete();
                         return true;
diff --git a/src/main/java/io/reactivex/internal/operators/parallel/ParallelJoin.java b/src/main/java/io/reactivex/internal/operators/parallel/ParallelJoin.java
index b248cde69f..975c151729 100644
--- a/src/main/java/io/reactivex/internal/operators/parallel/ParallelJoin.java
+++ b/src/main/java/io/reactivex/internal/operators/parallel/ParallelJoin.java
@@ -110,15 +110,13 @@ public void cancel() {
         }
 
         void cancelAll() {
-            for (int i = 0; i < subscribers.length; i++) {
-                JoinInnerSubscriber s = subscribers[i];
+            for (JoinInnerSubscriber s : subscribers) {
                 s.cancel();
             }
         }
 
         void cleanup() {
-            for (int i = 0; i < subscribers.length; i++) {
-                JoinInnerSubscriber s = subscribers[i];
+            for (JoinInnerSubscriber s : subscribers) {
                 s.queue = null;
             }
         }
diff --git a/src/main/java/io/reactivex/internal/operators/single/SingleAmb.java b/src/main/java/io/reactivex/internal/operators/single/SingleAmb.java
index d7508c3a72..2584506b59 100644
--- a/src/main/java/io/reactivex/internal/operators/single/SingleAmb.java
+++ b/src/main/java/io/reactivex/internal/operators/single/SingleAmb.java
@@ -59,21 +59,21 @@ protected void subscribeActual(final SingleObserver observer) {
             count = sources.length;
         }
 
+        final AtomicBoolean winner = new AtomicBoolean();
         final CompositeDisposable set = new CompositeDisposable();
 
-        AmbSingleObserver shared = new AmbSingleObserver(observer, set);
         observer.onSubscribe(set);
 
         for (int i = 0; i < count; i++) {
             SingleSource s1 = sources[i];
-            if (shared.get()) {
+            if (set.isDisposed()) {
                 return;
             }
 
             if (s1 == null) {
                 set.dispose();
                 Throwable e = new NullPointerException("One of the sources is null");
-                if (shared.compareAndSet(false, true)) {
+                if (winner.compareAndSet(false, true)) {
                     observer.onError(e);
                 } else {
                     RxJavaPlugins.onError(e);
@@ -81,31 +81,36 @@ protected void subscribeActual(final SingleObserver observer) {
                 return;
             }
 
-            s1.subscribe(shared);
+            s1.subscribe(new AmbSingleObserver(observer, set, winner));
         }
     }
 
-    static final class AmbSingleObserver extends AtomicBoolean implements SingleObserver {
-
-        private static final long serialVersionUID = -1944085461036028108L;
+    static final class AmbSingleObserver implements SingleObserver {
 
         final CompositeDisposable set;
 
         final SingleObserver downstream;
 
-        AmbSingleObserver(SingleObserver observer, CompositeDisposable set) {
+        final AtomicBoolean winner;
+
+        Disposable upstream;
+
+        AmbSingleObserver(SingleObserver observer, CompositeDisposable set, AtomicBoolean winner) {
             this.downstream = observer;
             this.set = set;
+            this.winner = winner;
         }
 
         @Override
         public void onSubscribe(Disposable d) {
+            this.upstream = d;
             set.add(d);
         }
 
         @Override
         public void onSuccess(T value) {
-            if (compareAndSet(false, true)) {
+            if (winner.compareAndSet(false, true)) {
+                set.delete(upstream);
                 set.dispose();
                 downstream.onSuccess(value);
             }
@@ -113,7 +118,8 @@ public void onSuccess(T value) {
 
         @Override
         public void onError(Throwable e) {
-            if (compareAndSet(false, true)) {
+            if (winner.compareAndSet(false, true)) {
+                set.delete(upstream);
                 set.dispose();
                 downstream.onError(e);
             } else {
diff --git a/src/main/java/io/reactivex/internal/operators/single/SingleDoOnTerminate.java b/src/main/java/io/reactivex/internal/operators/single/SingleDoOnTerminate.java
new file mode 100644
index 0000000000..7497aff902
--- /dev/null
+++ b/src/main/java/io/reactivex/internal/operators/single/SingleDoOnTerminate.java
@@ -0,0 +1,78 @@
+/**
+ * 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.internal.operators.single;
+
+import io.reactivex.Single;
+import io.reactivex.SingleObserver;
+import io.reactivex.SingleSource;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.CompositeException;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Action;
+
+public final class SingleDoOnTerminate extends Single {
+
+    final SingleSource source;
+
+    final Action onTerminate;
+
+    public SingleDoOnTerminate(SingleSource source, Action onTerminate) {
+        this.source = source;
+        this.onTerminate = onTerminate;
+    }
+
+    @Override
+    protected void subscribeActual(final SingleObserver observer) {
+        source.subscribe(new DoOnTerminate(observer));
+    }
+
+    final class DoOnTerminate implements SingleObserver {
+
+        final SingleObserver downstream;
+
+        DoOnTerminate(SingleObserver observer) {
+            this.downstream = observer;
+        }
+
+        @Override
+        public void onSubscribe(Disposable d) {
+            downstream.onSubscribe(d);
+        }
+
+        @Override
+        public void onSuccess(T value) {
+            try {
+                onTerminate.run();
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                downstream.onError(ex);
+                return;
+            }
+
+            downstream.onSuccess(value);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            try {
+                onTerminate.run();
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                e = new CompositeException(e, ex);
+            }
+
+            downstream.onError(e);
+        }
+    }
+}
diff --git a/src/main/java/io/reactivex/internal/schedulers/ExecutorScheduler.java b/src/main/java/io/reactivex/internal/schedulers/ExecutorScheduler.java
index 45e3c1850e..75322a8de8 100644
--- a/src/main/java/io/reactivex/internal/schedulers/ExecutorScheduler.java
+++ b/src/main/java/io/reactivex/internal/schedulers/ExecutorScheduler.java
@@ -22,7 +22,7 @@
 import io.reactivex.internal.disposables.*;
 import io.reactivex.internal.functions.Functions;
 import io.reactivex.internal.queue.MpscLinkedQueue;
-import io.reactivex.internal.schedulers.ExecutorScheduler.ExecutorWorker.BooleanRunnable;
+import io.reactivex.internal.schedulers.ExecutorScheduler.ExecutorWorker.*;
 import io.reactivex.plugins.RxJavaPlugins;
 import io.reactivex.schedulers.*;
 
@@ -31,19 +31,22 @@
  */
 public final class ExecutorScheduler extends Scheduler {
 
+    final boolean interruptibleWorker;
+
     @NonNull
     final Executor executor;
 
     static final Scheduler HELPER = Schedulers.single();
 
-    public ExecutorScheduler(@NonNull Executor executor) {
+    public ExecutorScheduler(@NonNull Executor executor, boolean interruptibleWorker) {
         this.executor = executor;
+        this.interruptibleWorker = interruptibleWorker;
     }
 
     @NonNull
     @Override
     public Worker createWorker() {
-        return new ExecutorWorker(executor);
+        return new ExecutorWorker(executor, interruptibleWorker);
     }
 
     @NonNull
@@ -58,9 +61,15 @@ public Disposable scheduleDirect(@NonNull Runnable run) {
                 return task;
             }
 
-            BooleanRunnable br = new BooleanRunnable(decoratedRun);
-            executor.execute(br);
-            return br;
+            if (interruptibleWorker) {
+                InterruptibleRunnable interruptibleTask = new InterruptibleRunnable(decoratedRun, null);
+                executor.execute(interruptibleTask);
+                return interruptibleTask;
+            } else {
+                BooleanRunnable br = new BooleanRunnable(decoratedRun);
+                executor.execute(br);
+                return br;
+            }
         } catch (RejectedExecutionException ex) {
             RxJavaPlugins.onError(ex);
             return EmptyDisposable.INSTANCE;
@@ -111,6 +120,9 @@ public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initial
     }
     /* public: test support. */
     public static final class ExecutorWorker extends Scheduler.Worker implements Runnable {
+
+        final boolean interruptibleWorker;
+
         final Executor executor;
 
         final MpscLinkedQueue queue;
@@ -121,9 +133,10 @@ public static final class ExecutorWorker extends Scheduler.Worker implements Run
 
         final CompositeDisposable tasks = new CompositeDisposable();
 
-        public ExecutorWorker(Executor executor) {
+        public ExecutorWorker(Executor executor, boolean interruptibleWorker) {
             this.executor = executor;
             this.queue = new MpscLinkedQueue();
+            this.interruptibleWorker = interruptibleWorker;
         }
 
         @NonNull
@@ -134,9 +147,24 @@ public Disposable schedule(@NonNull Runnable run) {
             }
 
             Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
-            BooleanRunnable br = new BooleanRunnable(decoratedRun);
 
-            queue.offer(br);
+            Runnable task;
+            Disposable disposable;
+
+            if (interruptibleWorker) {
+                InterruptibleRunnable interruptibleTask = new InterruptibleRunnable(decoratedRun, tasks);
+                tasks.add(interruptibleTask);
+
+                task = interruptibleTask;
+                disposable = interruptibleTask;
+            } else {
+                BooleanRunnable runnableTask = new BooleanRunnable(decoratedRun);
+
+                task = runnableTask;
+                disposable = runnableTask;
+            }
+
+            queue.offer(task);
 
             if (wip.getAndIncrement() == 0) {
                 try {
@@ -149,7 +177,7 @@ public Disposable schedule(@NonNull Runnable run) {
                 }
             }
 
-            return br;
+            return disposable;
         }
 
         @NonNull
@@ -288,6 +316,97 @@ public void run() {
                 mar.replace(schedule(decoratedRun));
             }
         }
+
+        /**
+         * Wrapper for a {@link Runnable} with additional logic for handling interruption on
+         * a shared thread, similar to how Java Executors do it.
+         */
+        static final class InterruptibleRunnable extends AtomicInteger implements Runnable, Disposable {
+
+            private static final long serialVersionUID = -3603436687413320876L;
+
+            final Runnable run;
+
+            final DisposableContainer tasks;
+
+            volatile Thread thread;
+
+            static final int READY = 0;
+
+            static final int RUNNING = 1;
+
+            static final int FINISHED = 2;
+
+            static final int INTERRUPTING = 3;
+
+            static final int INTERRUPTED = 4;
+
+            InterruptibleRunnable(Runnable run, DisposableContainer tasks) {
+                this.run = run;
+                this.tasks = tasks;
+            }
+
+            @Override
+            public void run() {
+                if (get() == READY) {
+                    thread = Thread.currentThread();
+                    if (compareAndSet(READY, RUNNING)) {
+                        try {
+                            run.run();
+                        } finally {
+                            thread = null;
+                            if (compareAndSet(RUNNING, FINISHED)) {
+                                cleanup();
+                            } else {
+                                while (get() == INTERRUPTING) {
+                                    Thread.yield();
+                                }
+                                Thread.interrupted();
+                            }
+                        }
+                    } else {
+                        thread = null;
+                    }
+                }
+            }
+
+            @Override
+            public void dispose() {
+                for (;;) {
+                    int state = get();
+                    if (state >= FINISHED) {
+                        break;
+                    } else if (state == READY) {
+                        if (compareAndSet(READY, INTERRUPTED)) {
+                            cleanup();
+                            break;
+                        }
+                    } else {
+                        if (compareAndSet(RUNNING, INTERRUPTING)) {
+                            Thread t = thread;
+                            if (t != null) {
+                                t.interrupt();
+                                thread = null;
+                            }
+                            set(INTERRUPTED);
+                            cleanup();
+                            break;
+                        }
+                    }
+                }
+            }
+
+            void cleanup() {
+                if (tasks != null) {
+                    tasks.delete(this);
+                }
+            }
+
+            @Override
+            public boolean isDisposed() {
+                return get() >= FINISHED;
+            }
+        }
     }
 
     static final class DelayedRunnable extends AtomicReference
diff --git a/src/main/java/io/reactivex/internal/schedulers/IoScheduler.java b/src/main/java/io/reactivex/internal/schedulers/IoScheduler.java
index d806321bf3..02cb44a1d3 100644
--- a/src/main/java/io/reactivex/internal/schedulers/IoScheduler.java
+++ b/src/main/java/io/reactivex/internal/schedulers/IoScheduler.java
@@ -48,6 +48,10 @@ public final class IoScheduler extends Scheduler {
     /** The name of the system property for setting the thread priority for this Scheduler. */
     private static final String KEY_IO_PRIORITY = "rx2.io-priority";
 
+    /** The name of the system property for setting the release behaviour for this Scheduler. */
+    private static final String KEY_SCHEDULED_RELEASE = "rx2.io-scheduled-release";
+    static boolean USE_SCHEDULED_RELEASE;
+
     static final CachedWorkerPool NONE;
 
     static {
@@ -63,6 +67,8 @@ public final class IoScheduler extends Scheduler {
 
         EVICTOR_THREAD_FACTORY = new RxThreadFactory(EVICTOR_THREAD_NAME_PREFIX, priority);
 
+        USE_SCHEDULED_RELEASE = Boolean.getBoolean(KEY_SCHEDULED_RELEASE);
+
         NONE = new CachedWorkerPool(0, null, WORKER_THREAD_FACTORY);
         NONE.shutdown();
     }
@@ -200,7 +206,7 @@ public int size() {
         return pool.get().allWorkers.size();
     }
 
-    static final class EventLoopWorker extends Scheduler.Worker {
+    static final class EventLoopWorker extends Scheduler.Worker implements Runnable {
         private final CompositeDisposable tasks;
         private final CachedWorkerPool pool;
         private final ThreadWorker threadWorker;
@@ -217,12 +223,20 @@ static final class EventLoopWorker extends Scheduler.Worker {
         public void dispose() {
             if (once.compareAndSet(false, true)) {
                 tasks.dispose();
-
-                // releasing the pool should be the last action
-                pool.release(threadWorker);
+                if (USE_SCHEDULED_RELEASE) {
+                    threadWorker.scheduleActual(this, 0, TimeUnit.NANOSECONDS, null);
+                } else {
+                    // releasing the pool should be the last action
+                    pool.release(threadWorker);
+                }
             }
         }
 
+        @Override
+        public void run() {
+            pool.release(threadWorker);
+        }
+
         @Override
         public boolean isDisposed() {
             return once.get();
diff --git a/src/main/java/io/reactivex/internal/schedulers/SchedulerPoolFactory.java b/src/main/java/io/reactivex/internal/schedulers/SchedulerPoolFactory.java
index b0b1339d29..ab465046aa 100644
--- a/src/main/java/io/reactivex/internal/schedulers/SchedulerPoolFactory.java
+++ b/src/main/java/io/reactivex/internal/schedulers/SchedulerPoolFactory.java
@@ -20,6 +20,8 @@
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicReference;
 
+import io.reactivex.functions.Function;
+
 /**
  * Manages the creating of ScheduledExecutorServices and sets up purging.
  */
@@ -90,40 +92,48 @@ public static void shutdown() {
     }
 
     static {
-        Properties properties = System.getProperties();
-
-        PurgeProperties pp = new PurgeProperties();
-        pp.load(properties);
-
-        PURGE_ENABLED = pp.purgeEnable;
-        PURGE_PERIOD_SECONDS = pp.purgePeriod;
+        SystemPropertyAccessor propertyAccessor = new SystemPropertyAccessor();
+        PURGE_ENABLED = getBooleanProperty(true, PURGE_ENABLED_KEY, true, true, propertyAccessor);
+        PURGE_PERIOD_SECONDS = getIntProperty(PURGE_ENABLED, PURGE_PERIOD_SECONDS_KEY, 1, 1, propertyAccessor);
 
         start();
     }
 
-    static final class PurgeProperties {
-
-        boolean purgeEnable;
-
-        int purgePeriod;
-
-        void load(Properties properties) {
-            if (properties.containsKey(PURGE_ENABLED_KEY)) {
-                purgeEnable = Boolean.parseBoolean(properties.getProperty(PURGE_ENABLED_KEY));
-            } else {
-                purgeEnable = true;
+    static int getIntProperty(boolean enabled, String key, int defaultNotFound, int defaultNotEnabled, Function propertyAccessor) {
+        if (enabled) {
+            try {
+                String value = propertyAccessor.apply(key);
+                if (value == null) {
+                    return defaultNotFound;
+                }
+                return Integer.parseInt(value);
+            } catch (Throwable ex) {
+                return defaultNotFound;
             }
+        }
+        return defaultNotEnabled;
+    }
 
-            if (purgeEnable && properties.containsKey(PURGE_PERIOD_SECONDS_KEY)) {
-                try {
-                    purgePeriod = Integer.parseInt(properties.getProperty(PURGE_PERIOD_SECONDS_KEY));
-                } catch (NumberFormatException ex) {
-                    purgePeriod = 1;
+    static boolean getBooleanProperty(boolean enabled, String key, boolean defaultNotFound, boolean defaultNotEnabled, Function propertyAccessor) {
+        if (enabled) {
+            try {
+                String value = propertyAccessor.apply(key);
+                if (value == null) {
+                    return defaultNotFound;
                 }
-            } else {
-                purgePeriod = 1;
+                return "true".equals(value);
+            } catch (Throwable ex) {
+                return defaultNotFound;
             }
         }
+        return defaultNotEnabled;
+    }
+
+    static final class SystemPropertyAccessor implements Function {
+        @Override
+        public String apply(String t) throws Exception {
+            return System.getProperty(t);
+        }
     }
 
     /**
diff --git a/src/main/java/io/reactivex/internal/subscribers/StrictSubscriber.java b/src/main/java/io/reactivex/internal/subscribers/StrictSubscriber.java
index 0fb9d5666c..c7770bf163 100644
--- a/src/main/java/io/reactivex/internal/subscribers/StrictSubscriber.java
+++ b/src/main/java/io/reactivex/internal/subscribers/StrictSubscriber.java
@@ -23,7 +23,7 @@
 
 /**
  * Ensures that the event flow between the upstream and downstream follow
- * the Reactive-Streams 1.0 specification by honoring the 3 additional rules
+ * the Reactive Streams 1.0 specification by honoring the 3 additional rules
  * (which are omitted in standard operators due to performance reasons).
  * 
    
  * 
  • §1.3: onNext should not be called concurrently until onSubscribe returns
    • 
diff --git a/src/main/java/io/reactivex/observables/ConnectableObservable.java b/src/main/java/io/reactivex/observables/ConnectableObservable.java
index b5e54054b1..09fa70899e 100644
--- a/src/main/java/io/reactivex/observables/ConnectableObservable.java
+++ b/src/main/java/io/reactivex/observables/ConnectableObservable.java
@@ -66,6 +66,23 @@ public final Disposable connect() {
         return cc.disposable;
     }
 
+    /**
+     * Apply a workaround for a race condition with the regular publish().refCount()
+     * so that racing observers and refCount won't hang.
+     * 
+     * @return the ConnectableObservable to work with
+     * @since 2.2.10
+     */
+    @SuppressWarnings("unchecked")
+    private ConnectableObservable onRefCount() {
+        if (this instanceof ObservablePublishClassic) {
+            return RxJavaPlugins.onAssembly(
+                    new ObservablePublishAlt(((ObservablePublishClassic)this).publishSource())
+                   );
+        }
+        return this;
+    }
+
     /**
      * Returns an {@code Observable} that stays connected to this {@code ConnectableObservable} as long as there
      * is at least one subscription to this {@code ConnectableObservable}.
@@ -83,7 +100,7 @@ public final Disposable connect() {
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.NONE)
     public Observable refCount() {
-        return RxJavaPlugins.onAssembly(new ObservableRefCount(this));
+        return RxJavaPlugins.onAssembly(new ObservableRefCount(onRefCount()));
     }
 
     /**
@@ -190,7 +207,7 @@ public final Observable refCount(int subscriberCount, long timeout, TimeUnit
         ObjectHelper.verifyPositive(subscriberCount, "subscriberCount");
         ObjectHelper.requireNonNull(unit, "unit is null");
         ObjectHelper.requireNonNull(scheduler, "scheduler is null");
-        return RxJavaPlugins.onAssembly(new ObservableRefCount(this, subscriberCount, timeout, unit, scheduler));
+        return RxJavaPlugins.onAssembly(new ObservableRefCount(onRefCount(), subscriberCount, timeout, unit, scheduler));
     }
 
     /**
diff --git a/src/main/java/io/reactivex/observers/BaseTestConsumer.java b/src/main/java/io/reactivex/observers/BaseTestConsumer.java
index 61db5a2356..4c92c27468 100644
--- a/src/main/java/io/reactivex/observers/BaseTestConsumer.java
+++ b/src/main/java/io/reactivex/observers/BaseTestConsumer.java
@@ -555,7 +555,6 @@ public final U assertValues(T... values) {
      * @return this
      * @since 2.2
      */
-    @SuppressWarnings("unchecked")
     public final U assertValuesOnly(T... values) {
         return assertSubscribed()
                 .assertValues(values)
diff --git a/src/main/java/io/reactivex/package-info.java b/src/main/java/io/reactivex/package-info.java
index 7d78294b6d..75ceb6cd7b 100644
--- a/src/main/java/io/reactivex/package-info.java
+++ b/src/main/java/io/reactivex/package-info.java
@@ -25,7 +25,7 @@
  * Completable/CompletableObserver interfaces and associated operators (in
  * the {@code io.reactivex.internal.operators} package) are inspired by the
  * Reactive Rx library in Microsoft .NET but designed and implemented on
- * the more advanced Reactive-Streams ( http://www.reactivestreams.org ) principles.
    
+ * the more advanced Reactive Streams ( http://www.reactivestreams.org ) principles.
    
  * 
    
  * More information can be found at http://msdn.microsoft.com/en-us/data/gg577609.
diff --git a/src/main/java/io/reactivex/processors/MulticastProcessor.java b/src/main/java/io/reactivex/processors/MulticastProcessor.java
index 317244313f..31b7a64fea 100644
--- a/src/main/java/io/reactivex/processors/MulticastProcessor.java
+++ b/src/main/java/io/reactivex/processors/MulticastProcessor.java
@@ -569,6 +569,7 @@ void drain() {
                 }
             }
 
+            consumed = c;
             missed = wip.addAndGet(-missed);
             if (missed == 0) {
                 break;
diff --git a/src/main/java/io/reactivex/processors/ReplayProcessor.java b/src/main/java/io/reactivex/processors/ReplayProcessor.java
index ff98ff25d9..b04a17d07e 100644
--- a/src/main/java/io/reactivex/processors/ReplayProcessor.java
+++ b/src/main/java/io/reactivex/processors/ReplayProcessor.java
@@ -1070,6 +1070,10 @@ void trim() {
             TimedNode h = head;
 
             for (;;) {
+                if (size <= 1) {
+                    head = h;
+                    break;
+                }
                 TimedNode next = h.get();
                 if (next == null) {
                     head = h;
@@ -1082,6 +1086,7 @@ void trim() {
                 }
 
                 h = next;
+                size--;
             }
 
         }
diff --git a/src/main/java/io/reactivex/processors/UnicastProcessor.java b/src/main/java/io/reactivex/processors/UnicastProcessor.java
index 94547b88fb..ec4d6c1a77 100644
--- a/src/main/java/io/reactivex/processors/UnicastProcessor.java
+++ b/src/main/java/io/reactivex/processors/UnicastProcessor.java
@@ -347,7 +347,6 @@ void drainFused(Subscriber a) {
         for (;;) {
 
             if (cancelled) {
-                q.clear();
                 downstream.lazySet(null);
                 return;
             }
@@ -550,10 +549,11 @@ public void cancel() {
 
             doTerminate();
 
-            if (!enableOperatorFusion) {
-                if (wip.getAndIncrement() == 0) {
+            downstream.lazySet(null);
+            if (wip.getAndIncrement() == 0) {
+                downstream.lazySet(null);
+                if (!enableOperatorFusion) {
                     queue.clear();
-                    downstream.lazySet(null);
                 }
             }
         }
diff --git a/src/main/java/io/reactivex/processors/package-info.java b/src/main/java/io/reactivex/processors/package-info.java
index 64caf9a4c4..b6a619372f 100644
--- a/src/main/java/io/reactivex/processors/package-info.java
+++ b/src/main/java/io/reactivex/processors/package-info.java
@@ -15,7 +15,25 @@
  */
 
 /**
- * Classes extending the Flowable base reactive class and implementing
- * the Subscriber interface at the same time (aka hot Flowables).
+ * Classes representing so-called hot backpressure-aware sources, aka processors,
+ * that implement the {@link io.reactivex.processors.FlowableProcessor FlowableProcessor} class,
+ * the Reactive Streams {@link org.reactivestreams.Processor Processor} interface
+ * to allow forms of multicasting events to one or more subscribers as well as consuming another
+ * Reactive Streams {@link org.reactivestreams.Publisher Publisher}.
+ * 
    
+ * Available processor implementations:
+ * 
    
+ * 
      
+ *     
    • {@link io.reactivex.processors.AsyncProcessor AsyncProcessor} - replays the very last item
      • 
+ *     
    • {@link io.reactivex.processors.BehaviorProcessor BehaviorProcessor} - remembers the latest item
      • 
+ *     
    • {@link io.reactivex.processors.MulticastProcessor MulticastProcessor} - coordinates its source with its consumers
      • 
+ *     
    • {@link io.reactivex.processors.PublishProcessor PublishProcessor} - dispatches items to current consumers
      • 
+ *     
    • {@link io.reactivex.processors.ReplayProcessor ReplayProcessor} - remembers some or all items and replays them to consumers
      • 
+ *     
    • {@link io.reactivex.processors.UnicastProcessor UnicastProcessor} - remembers or relays items to a single consumer
      • 
+ * 
    
+ * 
    
+ * The non-backpressured variants of the {@code FlowableProcessor} class are called
+ * {@link io.reactivex.subjects.Subject}s and reside in the {@code io.reactivex.subjects} package.
+ * @see io.reactivex.subjects
  */
 package io.reactivex.processors;
diff --git a/src/main/java/io/reactivex/schedulers/Schedulers.java b/src/main/java/io/reactivex/schedulers/Schedulers.java
index d3febba3ac..5af187c121 100644
--- a/src/main/java/io/reactivex/schedulers/Schedulers.java
+++ b/src/main/java/io/reactivex/schedulers/Schedulers.java
@@ -13,13 +13,13 @@
 
 package io.reactivex.schedulers;
 
+import java.util.concurrent.*;
+
 import io.reactivex.Scheduler;
-import io.reactivex.annotations.NonNull;
+import io.reactivex.annotations.*;
 import io.reactivex.internal.schedulers.*;
 import io.reactivex.plugins.RxJavaPlugins;
 
-import java.util.concurrent.*;
-
 /**
  * Static factory methods for returning standard Scheduler instances.
  * 
    
@@ -31,12 +31,16 @@
  * 
      
  * 
    • {@code rx2.io-keep-alive-time} (long): sets the keep-alive time of the {@link #io()} Scheduler workers, default is {@link IoScheduler#KEEP_ALIVE_TIME_DEFAULT}
      • 
  * 
    • {@code rx2.io-priority} (int): sets the thread priority of the {@link #io()} Scheduler, default is {@link Thread#NORM_PRIORITY}
      • 
+ * 
    • {@code rx2.io-scheduled-release} (boolean): {@code true} sets the worker release mode of the
+ * {@link #io()} Scheduler to scheduled, default is {@code false} for eager mode.
      • 
  * 
    • {@code rx2.computation-threads} (int): sets the number of threads in the {@link #computation()} Scheduler, default is the number of available CPUs
      • 
  * 
    • {@code rx2.computation-priority} (int): sets the thread priority of the {@link #computation()} Scheduler, default is {@link Thread#NORM_PRIORITY}
      • 
  * 
    • {@code rx2.newthread-priority} (int): sets the thread priority of the {@link #newThread()} Scheduler, default is {@link Thread#NORM_PRIORITY}
      • 
  * 
    • {@code rx2.single-priority} (int): sets the thread priority of the {@link #single()} Scheduler, default is {@link Thread#NORM_PRIORITY}
      • 
  * 
    • {@code rx2.purge-enabled} (boolean): enables periodic purging of all Scheduler's backing thread pools, default is false
      • 
  * 
    • {@code rx2.purge-period-seconds} (int): specifies the periodic purge interval of all Scheduler's backing thread pools, default is 1 second
      • 
+ * 
    • {@code rx2.scheduler.use-nanotime} (boolean): {@code true} instructs {@code Scheduler} to use {@link System#nanoTime()} for {@link Scheduler#now(TimeUnit)},
+ * instead of default {@link System#currentTimeMillis()} ({@code false})
      • 
  * 
    
  */
 public final class Schedulers {
@@ -113,6 +117,8 @@ private Schedulers() {
      * 
      
      * 
    • {@code rx2.computation-threads} (int): sets the number of threads in the {@link #computation()} Scheduler, default is the number of available CPUs
      • 
      * 
    • {@code rx2.computation-priority} (int): sets the thread priority of the {@link #computation()} Scheduler, default is {@link Thread#NORM_PRIORITY}
      • 
+     * 
    • {@code rx2.io-scheduled-release} (boolean): {@code true} sets the worker release mode of the
+     * {@code #io()} Scheduler to scheduled, default is {@code false} for eager mode.
      • 
      * 
    
      * 
    
      * The default value of this scheduler can be overridden at initialization time via the
@@ -129,6 +135,21 @@ private Schedulers() {
      * 
    Operators on the base reactive classes that use this scheduler are marked with the
      * @{@link io.reactivex.annotations.SchedulerSupport SchedulerSupport}({@link io.reactivex.annotations.SchedulerSupport#COMPUTATION COMPUTATION})
      * annotation.
+     * 
    
+     * When the {@link Scheduler.Worker} is disposed, the underlying worker can be released to the cached worker pool in two modes:
+     * 
      
+     * 
    • In eager mode (default), the underlying worker is returned immediately to the cached worker pool
+     *  and can be reused much quicker by operators. The drawback is that if the currently running task doesn't
+     * respond to interruption in time or at all, this may lead to delays or deadlock with the reuse use of the
+     * underlying worker.
+     * 
      • 
+     * 
    • In scheduled mode (enabled via the system parameter {@code rx2.io-scheduled-release}
+     * set to {@code true}), the underlying worker is returned to the cached worker pool only after the currently running task
+     * has finished. This can help prevent premature reuse of the underlying worker and likely won't lead to delays or
+     * deadlock with such reuses. The drawback is that the delay in release may lead to an excess amount of underlying
+     * workers being created.
+     * 
      • 
+     * 
    
      * @return a {@link Scheduler} meant for computation-bound work
      */
     @NonNull
@@ -299,6 +320,9 @@ public static Scheduler single() {
      * a time delay or periodically will use the {@link #single()} scheduler for the timed waiting
      * before posting the actual task to the given executor.
      * 
    
+     * Tasks submitted to the {@link io.reactivex.Scheduler.Worker Scheduler.Worker} of this {@code Scheduler} are also not interruptible. Use the
+     * {@link #from(Executor, boolean)} overload to enable task interruption via this wrapper.
+     * 
    
      * If the provided executor supports the standard Java {@link ExecutorService} API,
      * cancelling tasks scheduled by this scheduler can be cancelled/interrupted by calling
      * {@link io.reactivex.disposables.Disposable#dispose()}. In addition, tasks scheduled with
@@ -329,7 +353,7 @@ public static Scheduler single() {
      * }
      * 
      * 
    
-     * This type of scheduler is less sensitive to leaking {@link io.reactivex.Scheduler.Worker} instances, although
+     * This type of scheduler is less sensitive to leaking {@link io.reactivex.Scheduler.Worker Scheduler.Worker} instances, although
      * not disposing a worker that has timed/delayed tasks not cancelled by other means may leak resources and/or
      * execute those tasks "unexpectedly".
      * 
    
@@ -340,7 +364,67 @@ public static Scheduler single() {
      */
     @NonNull
     public static Scheduler from(@NonNull Executor executor) {
-        return new ExecutorScheduler(executor);
+        return new ExecutorScheduler(executor, false);
+    }
+
+    /**
+     * Wraps an {@link Executor} into a new Scheduler instance and delegates {@code schedule()}
+     * calls to it.
+     * 
    
+     * The tasks scheduled by the returned {@link Scheduler} and its {@link io.reactivex.Scheduler.Worker Scheduler.Worker}
+     * can be optionally interrupted.
+     * 
    
+     * If the provided executor doesn't support any of the more specific standard Java executor
+     * APIs, tasks scheduled with a time delay or periodically will use the
+     * {@link #single()} scheduler for the timed waiting
+     * before posting the actual task to the given executor.
+     * 
    
+     * If the provided executor supports the standard Java {@link ExecutorService} API,
+     * canceling tasks scheduled by this scheduler can be cancelled/interrupted by calling
+     * {@link io.reactivex.disposables.Disposable#dispose()}. In addition, tasks scheduled with
+     * a time delay or periodically will use the {@link #single()} scheduler for the timed waiting
+     * before posting the actual task to the given executor.
+     * 
    
+     * If the provided executor supports the standard Java {@link ScheduledExecutorService} API,
+     * canceling tasks scheduled by this scheduler can be cancelled/interrupted by calling
+     * {@link io.reactivex.disposables.Disposable#dispose()}. In addition, tasks scheduled with
+     * a time delay or periodically will use the provided executor. Note, however, if the provided
+     * {@code ScheduledExecutorService} instance is not single threaded, tasks scheduled
+     * with a time delay close to each other may end up executing in different order than
+     * the original schedule() call was issued. This limitation may be lifted in a future patch.
+     * 
    
+     * Starting, stopping and restarting this scheduler is not supported (no-op) and the provided
+     * executor's lifecycle must be managed externally:
+     * 
    
+     * ExecutorService exec = Executors.newSingleThreadedExecutor();
+     * try {
+     *     Scheduler scheduler = Schedulers.from(exec, true);
+     *     Flowable.just(1)
+     *        .subscribeOn(scheduler)
+     *        .map(v -> v + 1)
+     *        .observeOn(scheduler)
+     *        .blockingSubscribe(System.out::println);
+     * } finally {
+     *     exec.shutdown();
+     * }
+     * 
    
+     * 
    
+     * This type of scheduler is less sensitive to leaking {@link io.reactivex.Scheduler.Worker Scheduler.Worker} instances, although
+     * not disposing a worker that has timed/delayed tasks not cancelled by other means may leak resources and/or
+     * execute those tasks "unexpectedly".
+     * 
    
+     * Note that this method returns a new {@link Scheduler} instance, even for the same {@link Executor} instance.
+     * @param executor
+     *          the executor to wrap
+     * @param interruptibleWorker if {@code true} the tasks submitted to the {@link io.reactivex.Scheduler.Worker Scheduler.Worker} will
+     * be interrupted when the task is disposed.
+     * @return the new Scheduler wrapping the Executor
+     * @since 2.2.6 - experimental
+     */
+    @NonNull
+    @Experimental
+    public static Scheduler from(@NonNull Executor executor, boolean interruptibleWorker) {
+        return new ExecutorScheduler(executor, interruptibleWorker);
     }
 
     /**
diff --git a/src/main/java/io/reactivex/subjects/ReplaySubject.java b/src/main/java/io/reactivex/subjects/ReplaySubject.java
index 703692bd57..622854b5ec 100644
--- a/src/main/java/io/reactivex/subjects/ReplaySubject.java
+++ b/src/main/java/io/reactivex/subjects/ReplaySubject.java
@@ -1071,6 +1071,10 @@ void trim() {
             TimedNode h = head;
 
             for (;;) {
+                if (size <= 1) {
+                    head = h;
+                    break;
+                }
                 TimedNode next = h.get();
                 if (next == null) {
                     head = h;
@@ -1083,6 +1087,7 @@ void trim() {
                 }
 
                 h = next;
+                size--;
             }
 
         }
diff --git a/src/main/java/io/reactivex/subjects/UnicastSubject.java b/src/main/java/io/reactivex/subjects/UnicastSubject.java
index 8c3eae8af0..20aadbd460 100644
--- a/src/main/java/io/reactivex/subjects/UnicastSubject.java
+++ b/src/main/java/io/reactivex/subjects/UnicastSubject.java
@@ -420,7 +420,6 @@ void drainFused(Observer a) {
 
             if (disposed) {
                 downstream.lazySet(null);
-                q.clear();
                 return;
             }
             boolean d = done;
@@ -558,7 +557,9 @@ public void dispose() {
                 downstream.lazySet(null);
                 if (wip.getAndIncrement() == 0) {
                     downstream.lazySet(null);
-                    queue.clear();
+                    if (!enableOperatorFusion) {
+                        queue.clear();
+                    }
                 }
             }
         }
diff --git a/src/main/java/io/reactivex/subjects/package-info.java b/src/main/java/io/reactivex/subjects/package-info.java
index 8bd3b06ac2..091c223445 100644
--- a/src/main/java/io/reactivex/subjects/package-info.java
+++ b/src/main/java/io/reactivex/subjects/package-info.java
@@ -29,7 +29,7 @@
  *     
       {@link io.reactivex.subjects.BehaviorSubject BehaviorSubject}
  *     
       {@link io.reactivex.subjects.PublishSubject PublishSubject}
  *     
       {@link io.reactivex.subjects.ReplaySubject ReplaySubject}
- *     
       {@link io.reactivex.subjects.UnicastSubject UnicastSubjectSubject}
+ *     
       {@link io.reactivex.subjects.UnicastSubject UnicastSubject}
  *     
  *     {@link io.reactivex.Observable Observable}
  *     {@link io.reactivex.Observer Observer}
diff --git a/src/main/resources/META-INF/proguard/rxjava2.pro b/src/main/resources/META-INF/proguard/rxjava2.pro
new file mode 100644
index 0000000000..d51378e562
--- /dev/null
+++ b/src/main/resources/META-INF/proguard/rxjava2.pro
@@ -0,0 +1 @@
+-dontwarn java.util.concurrent.Flow*
\ No newline at end of file
diff --git a/src/test/java/io/reactivex/NotificationTest.java b/src/test/java/io/reactivex/NotificationTest.java
index c3283edd3c..504c0425bc 100644
--- a/src/test/java/io/reactivex/NotificationTest.java
+++ b/src/test/java/io/reactivex/NotificationTest.java
@@ -41,11 +41,11 @@ public void valueOfOnCompleteIsNull() {
     @Test
     public void notEqualsToObject() {
         Notification n1 = Notification.createOnNext(0);
-        assertFalse(n1.equals(0));
+        assertNotEquals(0, n1);
         Notification n2 = Notification.createOnError(new TestException());
-        assertFalse(n2.equals(0));
+        assertNotEquals(0, n2);
         Notification n3 = Notification.createOnComplete();
-        assertFalse(n3.equals(0));
+        assertNotEquals(0, n3);
     }
 
     @Test
diff --git a/src/test/java/io/reactivex/SchedulerTest.java b/src/test/java/io/reactivex/SchedulerTest.java
new file mode 100644
index 0000000000..39bcb0ae4b
--- /dev/null
+++ b/src/test/java/io/reactivex/SchedulerTest.java
@@ -0,0 +1,61 @@
+/**
+ * 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;
+
+import org.junit.After;
+import org.junit.Test;
+
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.*;
+
+/**
+ * Same as {@link io.reactivex.schedulers.SchedulerTest}, but different package, to access
+ * package-private fields.
+ */
+public class SchedulerTest {
+    private static final String DRIFT_USE_NANOTIME = "rx2.scheduler.use-nanotime";
+
+    @After
+    public void cleanup() {
+      // reset value to default in order to not influence other tests
+      Scheduler.IS_DRIFT_USE_NANOTIME = false;
+    }
+
+    @Test
+    public void driftUseNanoTimeNotSetByDefault() {
+      assertFalse(Scheduler.IS_DRIFT_USE_NANOTIME);
+      assertFalse(Boolean.getBoolean(DRIFT_USE_NANOTIME));
+    }
+
+    @Test
+    public void computeNow_currentTimeMillis() {
+      TimeUnit unit = TimeUnit.MILLISECONDS;
+      assertTrue(isInRange(System.currentTimeMillis(), Scheduler.computeNow(unit), unit, 250, TimeUnit.MILLISECONDS));
+    }
+
+    @Test
+    public void computeNow_nanoTime() {
+      TimeUnit unit = TimeUnit.NANOSECONDS;
+      Scheduler.IS_DRIFT_USE_NANOTIME = true;
+
+      assertFalse(isInRange(System.currentTimeMillis(), Scheduler.computeNow(unit), unit, 250, TimeUnit.MILLISECONDS));
+      assertTrue(isInRange(System.nanoTime(), Scheduler.computeNow(unit), TimeUnit.NANOSECONDS, 250, TimeUnit.MILLISECONDS));
+    }
+
+    private boolean isInRange(long start, long stop, TimeUnit source, long maxDiff, TimeUnit diffUnit) {
+      long diff = Math.abs(stop - start);
+      return diffUnit.convert(diff, source) <= maxDiff;
+    }
+}
diff --git a/src/test/java/io/reactivex/TimesteppingScheduler.java b/src/test/java/io/reactivex/TimesteppingScheduler.java
new file mode 100644
index 0000000000..1bf0df2b8e
--- /dev/null
+++ b/src/test/java/io/reactivex/TimesteppingScheduler.java
@@ -0,0 +1,65 @@
+/**
+ * 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;
+
+import java.util.concurrent.TimeUnit;
+
+import io.reactivex.Scheduler;
+import io.reactivex.disposables.*;
+
+/**
+ * Basic scheduler that produces an ever increasing {@link #now(TimeUnit)} value.
+ * Use this scheduler only as a time source!
+ */
+public class TimesteppingScheduler extends Scheduler {
+
+    final class TimesteppingWorker extends Worker {
+        @Override
+        public void dispose() {
+        }
+
+        @Override
+        public boolean isDisposed() {
+            return false;
+        }
+
+        @Override
+        public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
+            run.run();
+            return Disposables.disposed();
+        }
+
+        @Override
+        public long now(TimeUnit unit) {
+            return TimesteppingScheduler.this.now(unit);
+        }
+    }
+
+    public long time;
+
+    public boolean stepEnabled;
+
+    @Override
+    public Worker createWorker() {
+        return new TimesteppingWorker();
+    }
+
+    @Override
+    public long now(TimeUnit unit) {
+        if (stepEnabled) {
+            return time++;
+        }
+        return time;
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/io/reactivex/completable/CompletableTest.java b/src/test/java/io/reactivex/completable/CompletableTest.java
index 4798973835..40e52c8e24 100644
--- a/src/test/java/io/reactivex/completable/CompletableTest.java
+++ b/src/test/java/io/reactivex/completable/CompletableTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.completable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
@@ -2398,18 +2397,20 @@ public void retryTimes5Error() {
 
     @Test(timeout = 5000)
     public void retryTimes5Normal() {
-        final AtomicInteger calls = new AtomicInteger(5);
+        final AtomicInteger calls = new AtomicInteger();
 
         Completable c = Completable.fromAction(new Action() {
             @Override
             public void run() {
-                if (calls.decrementAndGet() != 0) {
+                if (calls.incrementAndGet() != 6) {
                     throw new TestException();
                 }
             }
         }).retry(5);
 
         c.blockingAwait();
+
+        assertEquals(6, calls.get());
     }
 
     @Test(expected = IllegalArgumentException.class)
@@ -4324,7 +4325,7 @@ public boolean test(Throwable t) {
         Assert.assertEquals(2, errors.size());
 
         Assert.assertTrue(errors.get(0).toString(), errors.get(0) instanceof TestException);
-        Assert.assertEquals(errors.get(0).toString(), null, errors.get(0).getMessage());
+        Assert.assertNull(errors.get(0).toString(), errors.get(0).getMessage());
         Assert.assertTrue(errors.get(1).toString(), errors.get(1) instanceof TestException);
         Assert.assertEquals(errors.get(1).toString(), "Forced inner failure", errors.get(1).getMessage());
     }
diff --git a/src/test/java/io/reactivex/disposables/DisposablesTest.java b/src/test/java/io/reactivex/disposables/DisposablesTest.java
index 779b85fead..531838acc1 100644
--- a/src/test/java/io/reactivex/disposables/DisposablesTest.java
+++ b/src/test/java/io/reactivex/disposables/DisposablesTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.disposables;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
diff --git a/src/test/java/io/reactivex/exceptions/CompositeExceptionTest.java b/src/test/java/io/reactivex/exceptions/CompositeExceptionTest.java
index 3625aa099a..2737b90712 100644
--- a/src/test/java/io/reactivex/exceptions/CompositeExceptionTest.java
+++ b/src/test/java/io/reactivex/exceptions/CompositeExceptionTest.java
@@ -364,7 +364,22 @@ public synchronized Throwable getCause() {
             }
         };
         CompositeException ex = new CompositeException(throwable);
-        assertSame(ex, ex.getRootCause(ex));
+        assertSame(ex0, ex.getRootCause(ex));
+    }
+
+    @Test
+    public void rootCauseSelf() {
+        Throwable throwable = new Throwable() {
+
+            private static final long serialVersionUID = -4398003222998914415L;
+
+            @Override
+            public synchronized Throwable getCause() {
+                return this;
+            }
+        };
+        CompositeException tmp = new CompositeException(new TestException());
+        assertSame(throwable, tmp.getRootCause(throwable));
     }
 }
 
diff --git a/src/test/java/io/reactivex/exceptions/OnNextValueTest.java b/src/test/java/io/reactivex/exceptions/OnNextValueTest.java
index 6e0541436b..c0d9df5981 100644
--- a/src/test/java/io/reactivex/exceptions/OnNextValueTest.java
+++ b/src/test/java/io/reactivex/exceptions/OnNextValueTest.java
@@ -71,7 +71,7 @@ public void onError(Throwable e) {
 
             assertTrue(trace, trace.contains("OnNextValue"));
 
-            assertTrue("No Cause on throwable" + e, e.getCause() != null);
+            assertNotNull("No Cause on throwable" + e, e.getCause());
 //            assertTrue(e.getCause().getClass().getSimpleName() + " no OnNextValue",
 //                    e.getCause() instanceof OnErrorThrowable.OnNextValue);
         }
diff --git a/src/test/java/io/reactivex/flowable/FlowableMergeTests.java b/src/test/java/io/reactivex/flowable/FlowableMergeTests.java
index 5c96bcf096..5facc6665f 100644
--- a/src/test/java/io/reactivex/flowable/FlowableMergeTests.java
+++ b/src/test/java/io/reactivex/flowable/FlowableMergeTests.java
@@ -69,7 +69,7 @@ public void testMergeCovariance3() {
 
         assertTrue(values.get(0) instanceof HorrorMovie);
         assertTrue(values.get(1) instanceof Movie);
-        assertTrue(values.get(2) != null);
+        assertNotNull(values.get(2));
         assertTrue(values.get(3) instanceof HorrorMovie);
     }
 
@@ -92,7 +92,7 @@ public Publisher call() {
 
         assertTrue(values.get(0) instanceof HorrorMovie);
         assertTrue(values.get(1) instanceof Movie);
-        assertTrue(values.get(2) != null);
+        assertNotNull(values.get(2));
         assertTrue(values.get(3) instanceof HorrorMovie);
     }
 
diff --git a/src/test/java/io/reactivex/flowable/FlowableNotificationTest.java b/src/test/java/io/reactivex/flowable/FlowableNotificationTest.java
index e068cb7399..37b79676d3 100644
--- a/src/test/java/io/reactivex/flowable/FlowableNotificationTest.java
+++ b/src/test/java/io/reactivex/flowable/FlowableNotificationTest.java
@@ -23,28 +23,28 @@ public class FlowableNotificationTest {
     public void testOnNextIntegerNotificationDoesNotEqualNullNotification() {
         final Notification integerNotification = Notification.createOnNext(1);
         final Notification nullNotification = Notification.createOnNext(null);
-        Assert.assertFalse(integerNotification.equals(nullNotification));
+        Assert.assertNotEquals(integerNotification, nullNotification);
     }
 
     @Test(expected = NullPointerException.class)
     public void testOnNextNullNotificationDoesNotEqualIntegerNotification() {
         final Notification integerNotification = Notification.createOnNext(1);
         final Notification nullNotification = Notification.createOnNext(null);
-        Assert.assertFalse(nullNotification.equals(integerNotification));
+        Assert.assertNotEquals(nullNotification, integerNotification);
     }
 
     @Test
     public void testOnNextIntegerNotificationsWhenEqual() {
         final Notification integerNotification = Notification.createOnNext(1);
         final Notification integerNotification2 = Notification.createOnNext(1);
-        Assert.assertTrue(integerNotification.equals(integerNotification2));
+        Assert.assertEquals(integerNotification, integerNotification2);
     }
 
     @Test
     public void testOnNextIntegerNotificationsWhenNotEqual() {
         final Notification integerNotification = Notification.createOnNext(1);
         final Notification integerNotification2 = Notification.createOnNext(2);
-        Assert.assertFalse(integerNotification.equals(integerNotification2));
+        Assert.assertNotEquals(integerNotification, integerNotification2);
     }
 
     @Test
@@ -52,7 +52,7 @@ public void testOnNextIntegerNotificationsWhenNotEqual() {
     public void testOnErrorIntegerNotificationDoesNotEqualNullNotification() {
         final Notification integerNotification = Notification.createOnError(new Exception());
         final Notification nullNotification = Notification.createOnError(null);
-        Assert.assertFalse(integerNotification.equals(nullNotification));
+        Assert.assertNotEquals(integerNotification, nullNotification);
     }
 
     @Test
@@ -60,7 +60,7 @@ public void testOnErrorIntegerNotificationDoesNotEqualNullNotification() {
     public void testOnErrorNullNotificationDoesNotEqualIntegerNotification() {
         final Notification integerNotification = Notification.createOnError(new Exception());
         final Notification nullNotification = Notification.createOnError(null);
-        Assert.assertFalse(nullNotification.equals(integerNotification));
+        Assert.assertNotEquals(nullNotification, integerNotification);
     }
 
     @Test
@@ -68,13 +68,13 @@ public void testOnErrorIntegerNotificationsWhenEqual() {
         final Exception exception = new Exception();
         final Notification onErrorNotification = Notification.createOnError(exception);
         final Notification onErrorNotification2 = Notification.createOnError(exception);
-        Assert.assertTrue(onErrorNotification.equals(onErrorNotification2));
+        Assert.assertEquals(onErrorNotification, onErrorNotification2);
     }
 
     @Test
     public void testOnErrorIntegerNotificationWhenNotEqual() {
         final Notification onErrorNotification = Notification.createOnError(new Exception());
         final Notification onErrorNotification2 = Notification.createOnError(new Exception());
-        Assert.assertFalse(onErrorNotification.equals(onErrorNotification2));
+        Assert.assertNotEquals(onErrorNotification, onErrorNotification2);
     }
 }
diff --git a/src/test/java/io/reactivex/flowable/FlowableTests.java b/src/test/java/io/reactivex/flowable/FlowableTests.java
index fa8026da6c..c9e226da9e 100644
--- a/src/test/java/io/reactivex/flowable/FlowableTests.java
+++ b/src/test/java/io/reactivex/flowable/FlowableTests.java
@@ -14,7 +14,6 @@
 package io.reactivex.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/flowable/FlowableWindowTests.java b/src/test/java/io/reactivex/flowable/FlowableWindowTests.java
index 9ef4211aa4..08151bcb8b 100644
--- a/src/test/java/io/reactivex/flowable/FlowableWindowTests.java
+++ b/src/test/java/io/reactivex/flowable/FlowableWindowTests.java
@@ -16,11 +16,15 @@
 import static org.junit.Assert.*;
 
 import java.util.*;
+import java.util.concurrent.TimeUnit;
 
 import org.junit.Test;
 
-import io.reactivex.Flowable;
+import io.reactivex.*;
 import io.reactivex.functions.*;
+import io.reactivex.processors.PublishProcessor;
+import io.reactivex.schedulers.TestScheduler;
+import io.reactivex.subscribers.TestSubscriber;
 
 public class FlowableWindowTests {
 
@@ -50,4 +54,43 @@ public void accept(List xs) {
         assertEquals(2, lists.size());
 
     }
+
+    @Test
+    public void timeSizeWindowAlternatingBounds() {
+        TestScheduler scheduler = new TestScheduler();
+        PublishProcessor pp = PublishProcessor.create();
+
+        TestSubscriber> ts = pp.window(5, TimeUnit.SECONDS, scheduler, 2)
+        .flatMapSingle(new Function, SingleSource>>() {
+            @Override
+            public SingleSource> apply(Flowable v) {
+                return v.toList();
+            }
+        })
+        .test();
+
+        pp.onNext(1);
+        pp.onNext(2);
+        ts.assertValueCount(1); // size bound hit
+
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        pp.onNext(3);
+        scheduler.advanceTimeBy(6, TimeUnit.SECONDS);
+        ts.assertValueCount(2); // time bound hit
+
+        pp.onNext(4);
+        pp.onNext(5);
+
+        ts.assertValueCount(3); // size bound hit again
+
+        pp.onNext(4);
+
+        scheduler.advanceTimeBy(6, TimeUnit.SECONDS);
+
+        ts.assertValueCount(4)
+        .assertNoErrors()
+        .assertNotComplete();
+
+        ts.cancel();
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/completable/CompletableAmbTest.java b/src/test/java/io/reactivex/internal/operators/completable/CompletableAmbTest.java
index 0e45cd1c1b..f4a8a084b8 100644
--- a/src/test/java/io/reactivex/internal/operators/completable/CompletableAmbTest.java
+++ b/src/test/java/io/reactivex/internal/operators/completable/CompletableAmbTest.java
@@ -16,6 +16,7 @@
 import static org.junit.Assert.*;
 
 import java.util.*;
+import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.Test;
@@ -23,10 +24,13 @@
 import io.reactivex.*;
 import io.reactivex.disposables.*;
 import io.reactivex.exceptions.TestException;
+import io.reactivex.functions.*;
+import io.reactivex.internal.functions.Functions;
 import io.reactivex.internal.operators.completable.CompletableAmb.Amb;
 import io.reactivex.observers.TestObserver;
 import io.reactivex.plugins.RxJavaPlugins;
 import io.reactivex.processors.PublishProcessor;
+import io.reactivex.schedulers.Schedulers;
 import io.reactivex.subjects.*;
 
 public class CompletableAmbTest {
@@ -173,6 +177,7 @@ public void ambRace() {
         CompositeDisposable cd = new CompositeDisposable();
         AtomicBoolean once = new AtomicBoolean();
         Amb a = new Amb(once, cd, to);
+        a.onSubscribe(Disposables.empty());
 
         a.onComplete();
         a.onComplete();
@@ -259,4 +264,54 @@ public void untilCompletableOtherError() {
         to.assertFailure(TestException.class);
     }
 
+    @Test
+    public void noWinnerErrorDispose() throws Exception {
+        final TestException ex = new TestException();
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            final AtomicBoolean interrupted = new AtomicBoolean();
+            final CountDownLatch cdl = new CountDownLatch(1);
+
+            Completable.ambArray(
+                    Completable.error(ex)
+                    .subscribeOn(Schedulers.single())
+                    .observeOn(Schedulers.computation()),
+                    Completable.never()
+            )
+            .subscribe(Functions.EMPTY_ACTION, new Consumer() {
+                @Override
+                public void accept(Throwable e) throws Exception {
+                    interrupted.set(Thread.currentThread().isInterrupted());
+                    cdl.countDown();
+                }
+            });
+
+            assertTrue(cdl.await(500, TimeUnit.SECONDS));
+            assertFalse("Interrupted!", interrupted.get());
+        }
+    }
+
+    @Test
+    public void noWinnerCompleteDispose() throws Exception {
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            final AtomicBoolean interrupted = new AtomicBoolean();
+            final CountDownLatch cdl = new CountDownLatch(1);
+
+            Completable.ambArray(
+                Completable.complete()
+                    .subscribeOn(Schedulers.single())
+                    .observeOn(Schedulers.computation()),
+                Completable.never()
+            )
+            .subscribe(new Action() {
+                @Override
+                public void run() throws Exception {
+                    interrupted.set(Thread.currentThread().isInterrupted());
+                    cdl.countDown();
+                }
+            });
+
+            assertTrue(cdl.await(500, TimeUnit.SECONDS));
+            assertFalse("Interrupted!", interrupted.get());
+        }
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/completable/CompletableAndThenCompletableabTest.java b/src/test/java/io/reactivex/internal/operators/completable/CompletableAndThenCompletableabTest.java
new file mode 100644
index 0000000000..34b9c82436
--- /dev/null
+++ b/src/test/java/io/reactivex/internal/operators/completable/CompletableAndThenCompletableabTest.java
@@ -0,0 +1,185 @@
+/**
+ * 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.internal.operators.completable;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.Test;
+
+import io.reactivex.*;
+import io.reactivex.exceptions.TestException;
+import io.reactivex.functions.Action;
+import io.reactivex.observers.TestObserver;
+import io.reactivex.schedulers.Schedulers;
+
+import static org.junit.Assert.*;
+
+public class CompletableAndThenCompletableabTest {
+    @Test(expected = NullPointerException.class)
+    public void andThenCompletableCompleteNull() {
+        Completable.complete()
+                .andThen((Completable) null);
+    }
+
+    @Test
+    public void andThenCompletableCompleteComplete() {
+        Completable.complete()
+                .andThen(Completable.complete())
+                .test()
+                .assertComplete();
+    }
+
+    @Test
+    public void andThenCompletableCompleteError() {
+        Completable.complete()
+                .andThen(Completable.error(new TestException("test")))
+                .test()
+                .assertNotComplete()
+                .assertNoValues()
+                .assertError(TestException.class)
+                .assertErrorMessage("test");
+    }
+
+    @Test
+    public void andThenCompletableCompleteNever() {
+        Completable.complete()
+                .andThen(Completable.never())
+                .test()
+                .assertNoValues()
+                .assertNoErrors()
+                .assertNotComplete();
+    }
+
+    @Test
+    public void andThenCompletableErrorComplete() {
+        Completable.error(new TestException("bla"))
+                .andThen(Completable.complete())
+                .test()
+                .assertNotComplete()
+                .assertNoValues()
+                .assertError(TestException.class)
+                .assertErrorMessage("bla");
+    }
+
+    @Test
+    public void andThenCompletableErrorNever() {
+        Completable.error(new TestException("bla"))
+                .andThen(Completable.never())
+                .test()
+                .assertNotComplete()
+                .assertNoValues()
+                .assertError(TestException.class)
+                .assertErrorMessage("bla");
+    }
+
+    @Test
+    public void andThenCompletableErrorError() {
+        Completable.error(new TestException("error1"))
+                .andThen(Completable.error(new TestException("error2")))
+                .test()
+                .assertNotComplete()
+                .assertNoValues()
+                .assertError(TestException.class)
+                .assertErrorMessage("error1");
+    }
+
+    @Test
+    public void andThenCanceled() {
+        final AtomicInteger completableRunCount = new AtomicInteger();
+        Completable.fromRunnable(new Runnable() {
+            @Override
+            public void run() {
+                completableRunCount.incrementAndGet();
+            }
+        })
+                .andThen(Completable.complete())
+                .test(true)
+                .assertEmpty();
+        assertEquals(1, completableRunCount.get());
+    }
+
+    @Test
+    public void andThenFirstCancels() {
+        final TestObserver to = new TestObserver();
+        Completable.fromRunnable(new Runnable() {
+            @Override
+            public void run() {
+                to.cancel();
+            }
+        })
+                .andThen(Completable.complete())
+                .subscribe(to);
+        to
+                .assertNotComplete()
+                .assertNoErrors();
+    }
+
+    @Test
+    public void andThenSecondCancels() {
+        final TestObserver to = new TestObserver();
+        Completable.complete()
+                .andThen(Completable.fromRunnable(new Runnable() {
+                    @Override
+                    public void run() {
+                        to.cancel();
+                    }
+                }))
+                .subscribe(to);
+        to
+                .assertNotComplete()
+                .assertNoErrors();
+    }
+
+    @Test
+    public void andThenDisposed() {
+        TestHelper.checkDisposed(Completable.complete()
+                .andThen(Completable.complete()));
+    }
+
+    @Test
+    public void andThenNoInterrupt() throws InterruptedException {
+        for (int k = 0; k < 100; k++) {
+            final int count = 10;
+            final CountDownLatch latch = new CountDownLatch(count);
+            final boolean[] interrupted = {false};
+
+            for (int i = 0; i < count; i++) {
+                Completable.complete()
+                        .subscribeOn(Schedulers.io())
+                        .observeOn(Schedulers.io())
+                        .andThen(Completable.fromAction(new Action() {
+                            @Override
+                            public void run() throws Exception {
+                                try {
+                                    Thread.sleep(30);
+                                } catch (InterruptedException e) {
+                                    System.out.println("Interrupted! " + Thread.currentThread());
+                                    interrupted[0] = true;
+                                }
+                            }
+                        }))
+                        .subscribe(new Action() {
+                            @Override
+                            public void run() throws Exception {
+                                latch.countDown();
+                            }
+                        });
+            }
+
+            latch.await();
+            assertFalse("The second Completable was interrupted!", interrupted[0]);
+        }
+    }
+}
diff --git a/src/test/java/io/reactivex/internal/operators/completable/CompletableAndThenTest.java b/src/test/java/io/reactivex/internal/operators/completable/CompletableAndThenTest.java
index a5d9b3a279..c873d5472d 100644
--- a/src/test/java/io/reactivex/internal/operators/completable/CompletableAndThenTest.java
+++ b/src/test/java/io/reactivex/internal/operators/completable/CompletableAndThenTest.java
@@ -13,15 +13,9 @@
 
 package io.reactivex.internal.operators.completable;
 
-import io.reactivex.Completable;
-import io.reactivex.Maybe;
-import io.reactivex.functions.Action;
-import io.reactivex.schedulers.Schedulers;
-
-import java.util.concurrent.CountDownLatch;
-
 import org.junit.Test;
-import static org.junit.Assert.*;
+
+import io.reactivex.*;
 
 public class CompletableAndThenTest {
     @Test(expected = NullPointerException.class)
@@ -69,39 +63,4 @@ public void andThenMaybeError() {
             .assertError(RuntimeException.class)
             .assertErrorMessage("bla");
     }
-
-    @Test
-    public void andThenNoInterrupt() throws InterruptedException {
-        for (int k = 0; k < 100; k++) {
-            final int count = 10;
-            final CountDownLatch latch = new CountDownLatch(count);
-            final boolean[] interrupted = { false };
-
-            for (int i = 0; i < count; i++) {
-                Completable.complete()
-                .subscribeOn(Schedulers.io())
-                .observeOn(Schedulers.io())
-                .andThen(Completable.fromAction(new Action() {
-                    @Override
-                    public void run() throws Exception {
-                        try {
-                            Thread.sleep(30);
-                        } catch (InterruptedException e) {
-                            System.out.println("Interrupted! " + Thread.currentThread());
-                            interrupted[0] = true;
-                        }
-                    }
-                }))
-                .subscribe(new Action() {
-                    @Override
-                    public void run() throws Exception {
-                        latch.countDown();
-                    }
-                });
-            }
-
-            latch.await();
-            assertFalse("The second Completable was interrupted!", interrupted[0]);
-        }
-    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/completable/CompletableFromCallableTest.java b/src/test/java/io/reactivex/internal/operators/completable/CompletableFromCallableTest.java
index b0d551a64e..412e3a2d1f 100644
--- a/src/test/java/io/reactivex/internal/operators/completable/CompletableFromCallableTest.java
+++ b/src/test/java/io/reactivex/internal/operators/completable/CompletableFromCallableTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.completable;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.concurrent.*;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableLatestTest.java b/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableLatestTest.java
index 92dcd3dd02..a0249db01e 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableLatestTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableLatestTest.java
@@ -43,13 +43,13 @@ public void testSimple() {
         for (int i = 0; i < 9; i++) {
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
 
-            Assert.assertEquals(true, it.hasNext());
+            Assert.assertTrue(it.hasNext());
 
             Assert.assertEquals(Long.valueOf(i), it.next());
         }
 
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        Assert.assertEquals(false, it.hasNext());
+        Assert.assertFalse(it.hasNext());
     }
 
     @Test(timeout = 1000)
@@ -68,13 +68,13 @@ public void testSameSourceMultipleIterators() {
             for (int i = 0; i < 9; i++) {
                 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
 
-                Assert.assertEquals(true, it.hasNext());
+                Assert.assertTrue(it.hasNext());
 
                 Assert.assertEquals(Long.valueOf(i), it.next());
             }
 
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-            Assert.assertEquals(false, it.hasNext());
+            Assert.assertFalse(it.hasNext());
         }
     }
 
@@ -86,7 +86,7 @@ public void testEmpty() {
 
         Iterator it = iter.iterator();
 
-        Assert.assertEquals(false, it.hasNext());
+        Assert.assertFalse(it.hasNext());
 
         it.next();
     }
@@ -165,7 +165,7 @@ public void testFasterSource() {
         source.onNext(7);
         source.onComplete();
 
-        Assert.assertEquals(false, it.hasNext());
+        Assert.assertFalse(it.hasNext());
     }
 
     @Ignore("THe target is an enum")
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableMostRecentTest.java b/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableMostRecentTest.java
index 26e6eb5716..70a43694d4 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableMostRecentTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableMostRecentTest.java
@@ -28,7 +28,7 @@
 public class BlockingFlowableMostRecentTest {
     @Test
     public void testMostRecentNull() {
-        assertEquals(null, Flowable.never().blockingMostRecent(null).iterator().next());
+        assertNull(Flowable.never().blockingMostRecent(null).iterator().next());
     }
 
     @Test
@@ -87,12 +87,12 @@ public void testSingleSourceManyIterators() {
             for (int i = 0; i < 9; i++) {
                 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
 
-                Assert.assertEquals(true, it.hasNext());
+                Assert.assertTrue(it.hasNext());
                 Assert.assertEquals(Long.valueOf(i), it.next());
             }
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
 
-            Assert.assertEquals(false, it.hasNext());
+            Assert.assertFalse(it.hasNext());
         }
 
     }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableNextTest.java b/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableNextTest.java
index 32ee150cf3..e2e2cc4337 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableNextTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableNextTest.java
@@ -318,7 +318,7 @@ public void testSingleSourceManyIterators() throws InterruptedException {
             BlockingFlowableNext.NextIterator it = (BlockingFlowableNext.NextIterator)iter.iterator();
 
             for (long i = 0; i < 10; i++) {
-                Assert.assertEquals(true, it.hasNext());
+                Assert.assertTrue(it.hasNext());
                 Assert.assertEquals(j + "th iteration next", Long.valueOf(i), it.next());
             }
             terminal.onNext(1);
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableToFutureTest.java b/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableToFutureTest.java
index d90b0b2f43..c1363a452b 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableToFutureTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableToFutureTest.java
@@ -120,6 +120,6 @@ public void testGetWithEmptyFlowable() throws Throwable {
     public void testGetWithASingleNullItem() throws Exception {
         Flowable obs = Flowable.just((String)null);
         Future f = obs.toFuture();
-        assertEquals(null, f.get());
+        assertNull(f.get());
     }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableToIteratorTest.java b/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableToIteratorTest.java
index 412d59ac5f..68490f9257 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableToIteratorTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/BlockingFlowableToIteratorTest.java
@@ -16,14 +16,18 @@
 import static org.junit.Assert.*;
 
 import java.util.*;
+import java.util.concurrent.TimeUnit;
 
 import org.junit.*;
 import org.reactivestreams.*;
 
 import io.reactivex.Flowable;
+import io.reactivex.disposables.Disposable;
 import io.reactivex.exceptions.*;
 import io.reactivex.internal.operators.flowable.BlockingFlowableIterable.BlockingFlowableIterator;
 import io.reactivex.internal.subscriptions.BooleanSubscription;
+import io.reactivex.processors.PublishProcessor;
+import io.reactivex.schedulers.Schedulers;
 
 public class BlockingFlowableToIteratorTest {
 
@@ -33,16 +37,16 @@ public void testToIterator() {
 
         Iterator it = obs.blockingIterable().iterator();
 
-        assertEquals(true, it.hasNext());
+        assertTrue(it.hasNext());
         assertEquals("one", it.next());
 
-        assertEquals(true, it.hasNext());
+        assertTrue(it.hasNext());
         assertEquals("two", it.next());
 
-        assertEquals(true, it.hasNext());
+        assertTrue(it.hasNext());
         assertEquals("three", it.next());
 
-        assertEquals(false, it.hasNext());
+        assertFalse(it.hasNext());
 
     }
 
@@ -60,10 +64,10 @@ public void subscribe(Subscriber subscriber) {
 
         Iterator it = obs.blockingIterable().iterator();
 
-        assertEquals(true, it.hasNext());
+        assertTrue(it.hasNext());
         assertEquals("one", it.next());
 
-        assertEquals(true, it.hasNext());
+        assertTrue(it.hasNext());
         it.next();
     }
 
@@ -185,4 +189,28 @@ protected void subscribeActual(Subscriber s) {
 
         it.next();
     }
+
+    @Test(expected = NoSuchElementException.class)
+    public void disposedIteratorHasNextReturns() {
+        Iterator it = PublishProcessor.create()
+                .blockingIterable().iterator();
+        ((Disposable)it).dispose();
+        assertFalse(it.hasNext());
+        it.next();
+    }
+
+    @Test
+    public void asyncDisposeUnblocks() {
+        final Iterator it = PublishProcessor.create()
+                .blockingIterable().iterator();
+
+        Schedulers.single().scheduleDirect(new Runnable() {
+            @Override
+            public void run() {
+                ((Disposable)it).dispose();
+            }
+        }, 1, TimeUnit.SECONDS);
+
+        assertFalse(it.hasNext());
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableAllTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableAllTest.java
index e859766ca8..409510b23f 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableAllTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableAllTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableAmbTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableAmbTest.java
index a4b03c633c..5b5941fbf4 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableAmbTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableAmbTest.java
@@ -19,8 +19,8 @@
 import java.io.IOException;
 import java.lang.reflect.Method;
 import java.util.*;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
 
 import org.junit.*;
 import org.mockito.InOrder;
@@ -30,6 +30,7 @@
 import io.reactivex.disposables.CompositeDisposable;
 import io.reactivex.exceptions.TestException;
 import io.reactivex.functions.*;
+import io.reactivex.internal.functions.Functions;
 import io.reactivex.internal.util.CrashingMappedIterable;
 import io.reactivex.plugins.RxJavaPlugins;
 import io.reactivex.processors.PublishProcessor;
@@ -713,4 +714,83 @@ public void ambArrayOrder() {
         Flowable error = Flowable.error(new RuntimeException());
         Flowable.ambArray(Flowable.just(1), error).test().assertValue(1).assertComplete();
     }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void noWinnerSuccessDispose() throws Exception {
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            final AtomicBoolean interrupted = new AtomicBoolean();
+            final CountDownLatch cdl = new CountDownLatch(1);
+
+            Flowable.ambArray(
+                Flowable.just(1)
+                    .subscribeOn(Schedulers.single())
+                    .observeOn(Schedulers.computation()),
+                Flowable.never()
+            )
+            .subscribe(new Consumer() {
+                @Override
+                public void accept(Object v) throws Exception {
+                    interrupted.set(Thread.currentThread().isInterrupted());
+                    cdl.countDown();
+                }
+            });
+
+            assertTrue(cdl.await(500, TimeUnit.SECONDS));
+            assertFalse("Interrupted!", interrupted.get());
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void noWinnerErrorDispose() throws Exception {
+        final TestException ex = new TestException();
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            final AtomicBoolean interrupted = new AtomicBoolean();
+            final CountDownLatch cdl = new CountDownLatch(1);
+
+            Flowable.ambArray(
+                Flowable.error(ex)
+                    .subscribeOn(Schedulers.single())
+                    .observeOn(Schedulers.computation()),
+                Flowable.never()
+            )
+            .subscribe(Functions.emptyConsumer(), new Consumer() {
+                @Override
+                public void accept(Throwable e) throws Exception {
+                    interrupted.set(Thread.currentThread().isInterrupted());
+                    cdl.countDown();
+                }
+            });
+
+            assertTrue(cdl.await(500, TimeUnit.SECONDS));
+            assertFalse("Interrupted!", interrupted.get());
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void noWinnerCompleteDispose() throws Exception {
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            final AtomicBoolean interrupted = new AtomicBoolean();
+            final CountDownLatch cdl = new CountDownLatch(1);
+
+            Flowable.ambArray(
+                Flowable.empty()
+                    .subscribeOn(Schedulers.single())
+                    .observeOn(Schedulers.computation()),
+                Flowable.never()
+            )
+            .subscribe(Functions.emptyConsumer(), Functions.emptyConsumer(), new Action() {
+                @Override
+                public void run() throws Exception {
+                    interrupted.set(Thread.currentThread().isInterrupted());
+                    cdl.countDown();
+                }
+            });
+
+            assertTrue(cdl.await(500, TimeUnit.SECONDS));
+            assertFalse("Interrupted!", interrupted.get());
+        }
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableAnyTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableAnyTest.java
index 76d4b034b7..5c8a9d6f84 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableAnyTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableAnyTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableAsObservableTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableAsObservableTest.java
index a297911040..7dd78955ee 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableAsObservableTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableAsObservableTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.assertFalse;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import org.junit.Test;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableBufferTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableBufferTest.java
index 5060c58253..d0023d3e38 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableBufferTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableBufferTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
@@ -2769,4 +2768,20 @@ public void timedSizeBufferAlreadyCleared() {
 
         sub.run();
     }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void bufferExactFailingSupplier() {
+        Flowable.empty()
+                .buffer(1, TimeUnit.SECONDS, Schedulers.computation(), 10, new Callable>() {
+                    @Override
+                    public List call() throws Exception {
+                        throw new TestException();
+                    }
+                }, false)
+                .test()
+                .awaitDone(1, TimeUnit.SECONDS)
+                .assertFailure(TestException.class)
+        ;
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableCombineLatestTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableCombineLatestTest.java
index 4443a71759..a96b8c8193 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableCombineLatestTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableCombineLatestTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.lang.reflect.*;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableConcatMapEagerTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableConcatMapEagerTest.java
index 1e34d2937b..11f12fb4a3 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableConcatMapEagerTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableConcatMapEagerTest.java
@@ -1333,4 +1333,37 @@ public void arrayDelayErrorMaxConcurrencyErrorDelayed() {
 
         ts.assertFailure(TestException.class, 1, 2);
     }
+
+    @Test
+    public void cancelActive() {
+        PublishProcessor pp1 = PublishProcessor.create();
+        PublishProcessor pp2 = PublishProcessor.create();
+
+        TestSubscriber ts = Flowable
+                .concatEager(Flowable.just(pp1, pp2))
+                .test();
+
+        assertTrue(pp1.hasSubscribers());
+        assertTrue(pp2.hasSubscribers());
+
+        ts.cancel();
+
+        assertFalse(pp1.hasSubscribers());
+        assertFalse(pp2.hasSubscribers());
+    }
+
+    @Test
+    public void cancelNoInnerYet() {
+        PublishProcessor> pp1 = PublishProcessor.create();
+
+        TestSubscriber ts = Flowable
+                .concatEager(pp1)
+                .test();
+
+        assertTrue(pp1.hasSubscribers());
+
+        ts.cancel();
+
+        assertFalse(pp1.hasSubscribers());
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableConcatMapTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableConcatMapTest.java
index eba09e564f..8bd29121a0 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableConcatMapTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableConcatMapTest.java
@@ -15,16 +15,18 @@
 
 import static org.junit.Assert.assertEquals;
 
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Test;
 import org.reactivestreams.Publisher;
 
 import io.reactivex.*;
-import io.reactivex.exceptions.TestException;
+import io.reactivex.exceptions.*;
 import io.reactivex.functions.*;
-import io.reactivex.internal.operators.flowable.FlowableConcatMap.WeakScalarSubscription;
+import io.reactivex.internal.functions.Functions;
+import io.reactivex.internal.operators.flowable.FlowableConcatMap.SimpleScalarSubscription;
+import io.reactivex.processors.PublishProcessor;
 import io.reactivex.schedulers.Schedulers;
 import io.reactivex.subscribers.TestSubscriber;
 
@@ -33,7 +35,7 @@ public class FlowableConcatMapTest {
     @Test
     public void weakSubscriptionRequest() {
         TestSubscriber ts = new TestSubscriber(0);
-        WeakScalarSubscription ws = new WeakScalarSubscription(1, ts);
+        SimpleScalarSubscription ws = new SimpleScalarSubscription(1, ts);
         ts.onSubscribe(ws);
 
         ws.request(0);
@@ -105,6 +107,68 @@ public Publisher apply(String v)
         .assertResult("RxSingleScheduler");
     }
 
+    @Test
+    public void innerScalarRequestRace() {
+        final Flowable just = Flowable.just(1);
+        final int n = 1000;
+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+            final PublishProcessor> source = PublishProcessor.create();
+
+            final TestSubscriber ts = source
+                    .concatMap(Functions.>identity(), n + 1)
+                    .test(1L);
+
+            TestHelper.race(new Runnable() {
+                @Override
+                public void run() {
+                    for (int j = 0; j < n; j++) {
+                        source.onNext(just);
+                    }
+                }
+            }, new Runnable() {
+                @Override
+                public void run() {
+                    for (int j = 0; j < n; j++) {
+                        ts.request(1);
+                    }
+                }
+            });
+
+            ts.assertValueCount(n);
+        }
+    }
+
+    @Test
+    public void innerScalarRequestRaceDelayError() {
+        final Flowable just = Flowable.just(1);
+        final int n = 1000;
+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+            final PublishProcessor> source = PublishProcessor.create();
+
+            final TestSubscriber ts = source
+                    .concatMapDelayError(Functions.>identity(), n + 1, true)
+                    .test(1L);
+
+            TestHelper.race(new Runnable() {
+                @Override
+                public void run() {
+                    for (int j = 0; j < n; j++) {
+                        source.onNext(just);
+                    }
+                }
+            }, new Runnable() {
+                @Override
+                public void run() {
+                    for (int j = 0; j < n; j++) {
+                        ts.request(1);
+                    }
+                }
+            });
+
+            ts.assertValueCount(n);
+        }
+    }
+
     @Test
     public void pollThrows() {
         Flowable.just(1)
@@ -168,4 +232,42 @@ public void run() throws Exception {
 
         assertEquals(0, counter.get());
     }
+
+    @Test
+    public void delayErrorCallableTillTheEnd() {
+        Flowable.just(1, 2, 3, 101, 102, 23, 890, 120, 32)
+        .concatMapDelayError(new Function>() {
+          @Override public Flowable apply(final Integer integer) throws Exception {
+            return Flowable.fromCallable(new Callable() {
+              @Override public Integer call() throws Exception {
+                if (integer >= 100) {
+                  throw new NullPointerException("test null exp");
+                }
+                return integer;
+              }
+            });
+          }
+        })
+        .test()
+        .assertFailure(CompositeException.class, 1, 2, 3, 23, 32);
+    }
+
+    @Test
+    public void delayErrorCallableEager() {
+        Flowable.just(1, 2, 3, 101, 102, 23, 890, 120, 32)
+        .concatMapDelayError(new Function>() {
+          @Override public Flowable apply(final Integer integer) throws Exception {
+            return Flowable.fromCallable(new Callable() {
+              @Override public Integer call() throws Exception {
+                if (integer >= 100) {
+                  throw new NullPointerException("test null exp");
+                }
+                return integer;
+              }
+            });
+          }
+        }, 2, false)
+        .test()
+        .assertFailure(NullPointerException.class, 1, 2, 3);
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableConcatTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableConcatTest.java
index 772f559733..c1faba86d4 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableConcatTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableConcatTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.lang.reflect.Method;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableDebounceTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableDebounceTest.java
index 8df7c9c193..aacff6e5af 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableDebounceTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableDebounceTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
@@ -547,4 +546,14 @@ public void timedError() {
         .test()
         .assertFailure(TestException.class);
     }
+
+    @Test
+    public void debounceOnEmpty() {
+        Flowable.empty().debounce(new Function>() {
+            @Override
+            public Publisher apply(Object o) {
+                return Flowable.just(new Object());
+            }
+        }).subscribe();
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableDelayTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableDelayTest.java
index 401b9c62b4..cf1817e0e4 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableDelayTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableDelayTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableDematerializeTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableDematerializeTest.java
index 66fd932dcc..723d3b1e59 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableDematerializeTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableDematerializeTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.flowable;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableDistinctTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableDistinctTest.java
index 448e963d49..86b6200440 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableDistinctTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableDistinctTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableDistinctUntilChangedTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableDistinctUntilChangedTest.java
index 7c5eb993e1..0ea9353505 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableDistinctUntilChangedTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableDistinctUntilChangedTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.flowable;
 
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableDoOnEachTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableDoOnEachTest.java
index 4a9ac3eca2..e61fdc4b38 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableDoOnEachTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableDoOnEachTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableFilterTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableFilterTest.java
index 85093c4576..a6928a1157 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableFilterTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableFilterTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.flowable;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableFlatMapTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableFlatMapTest.java
index 4c1441775b..e232af7bd4 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableFlatMapTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableFlatMapTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
@@ -1124,4 +1123,61 @@ public void accept(Integer v) throws Exception {
         assertFalse(pp3.hasSubscribers());
         assertFalse(pp4.hasSubscribers());
     }
+
+    @Test
+    public void mainErrorsInnerCancelled() {
+        PublishProcessor pp1 = PublishProcessor.create();
+        PublishProcessor pp2 = PublishProcessor.create();
+
+        pp1
+        .flatMap(Functions.justFunction(pp2))
+        .test();
+
+        pp1.onNext(1);
+        assertTrue("No subscribers?", pp2.hasSubscribers());
+
+        pp1.onError(new TestException());
+
+        assertFalse("Has subscribers?", pp2.hasSubscribers());
+    }
+
+    @Test
+    public void innerErrorsMainCancelled() {
+        PublishProcessor pp1 = PublishProcessor.create();
+        PublishProcessor pp2 = PublishProcessor.create();
+
+        pp1
+        .flatMap(Functions.justFunction(pp2))
+        .test();
+
+        pp1.onNext(1);
+        assertTrue("No subscribers?", pp2.hasSubscribers());
+
+        pp2.onError(new TestException());
+
+        assertFalse("Has subscribers?", pp1.hasSubscribers());
+    }
+
+    @Test(timeout = 5000)
+    public void mixedScalarAsync() {
+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+            Flowable
+            .range(0, 20)
+            .flatMap(new Function>() {
+                @Override
+                public Publisher apply(Integer integer) throws Exception {
+                    if (integer % 5 != 0) {
+                        return Flowable
+                                .just(integer);
+                    }
+
+                    return Flowable
+                            .just(-integer)
+                            .observeOn(Schedulers.computation());
+                }
+            }, false, 1)
+            .ignoreElements()
+            .blockingAwait();
+        }
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableFromCallableTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableFromCallableTest.java
index f3239001ee..254274b1cf 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableFromCallableTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableFromCallableTest.java
@@ -17,7 +17,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableFromIterableTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableFromIterableTest.java
index e33556cb4e..d2e15fa60d 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableFromIterableTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableFromIterableTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableGroupByTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableGroupByTest.java
index 97a0a5ca23..cb52621bac 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableGroupByTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableGroupByTest.java
@@ -30,12 +30,13 @@
 import com.google.common.cache.*;
 
 import io.reactivex.*;
-import io.reactivex.exceptions.TestException;
+import io.reactivex.exceptions.*;
 import io.reactivex.flowables.GroupedFlowable;
 import io.reactivex.functions.*;
 import io.reactivex.internal.functions.Functions;
-import io.reactivex.internal.fuseable.QueueFuseable;
+import io.reactivex.internal.fuseable.*;
 import io.reactivex.internal.subscriptions.BooleanSubscription;
+import io.reactivex.plugins.RxJavaPlugins;
 import io.reactivex.processors.PublishProcessor;
 import io.reactivex.schedulers.Schedulers;
 import io.reactivex.subjects.PublishSubject;
@@ -2206,4 +2207,147 @@ public void accept(Object object) {
                     }};
         return evictingMapFactory;
     }
+
+    @Test
+    public void fusedNoConcurrentCleanDueToCancel() {
+        for (int j = 0; j < TestHelper.RACE_LONG_LOOPS; j++) {
+            List errors = TestHelper.trackPluginErrors();
+            try {
+                final PublishProcessor pp = PublishProcessor.create();
+
+                final AtomicReference>> qs = new AtomicReference>>();
+
+                final TestSubscriber ts2 = new TestSubscriber();
+
+                pp.groupBy(Functions.identity(), Functions.identity(), false, 4)
+                .subscribe(new FlowableSubscriber>() {
+
+                    boolean once;
+
+                    @Override
+                    public void onNext(GroupedFlowable g) {
+                        if (!once) {
+                            try {
+                                GroupedFlowable t = qs.get().poll();
+                                if (t != null) {
+                                    once = true;
+                                    t.subscribe(ts2);
+                                }
+                            } catch (Throwable ignored) {
+                                // not relevant here
+                            }
+                        }
+                    }
+
+                    @Override
+                    public void onError(Throwable t) {
+                    }
+
+                    @Override
+                    public void onComplete() {
+                    }
+
+                    @Override
+                    public void onSubscribe(Subscription s) {
+                        @SuppressWarnings("unchecked")
+                        QueueSubscription> q = (QueueSubscription>)s;
+                        qs.set(q);
+                        q.requestFusion(QueueFuseable.ANY);
+                        q.request(1);
+                    }
+                })
+                ;
+
+                Runnable r1 = new Runnable() {
+                    @Override
+                    public void run() {
+                        qs.get().cancel();
+                        qs.get().clear();
+                    }
+                };
+                Runnable r2 = new Runnable() {
+                    @Override
+                    public void run() {
+                        ts2.cancel();
+                    }
+                };
+
+                for (int i = 0; i < 100; i++) {
+                    pp.onNext(i);
+                }
+
+                TestHelper.race(r1, r2);
+
+                if (!errors.isEmpty()) {
+                    throw new CompositeException(errors);
+                }
+            } finally {
+                RxJavaPlugins.reset();
+            }
+        }
+    }
+
+    @Test
+    public void fusedParallelGroupProcessing() {
+        Flowable.range(0, 500000)
+        .subscribeOn(Schedulers.single())
+        .groupBy(new Function() {
+            @Override
+            public Integer apply(Integer i) {
+                return i % 2;
+            }
+        })
+        .flatMap(new Function, Publisher>() {
+            @Override
+            public Publisher apply(GroupedFlowable g) {
+                return g.getKey() == 0
+                    ? g
+                        .parallel()
+                        .runOn(Schedulers.computation())
+                        .map(Functions.identity())
+                        .sequential()
+                    : g.map(Functions.identity()) // no need to use hide
+                ;
+            }
+        })
+        .test()
+        .awaitDone(20, TimeUnit.SECONDS)
+        .assertValueCount(500000)
+        .assertComplete()
+        .assertNoErrors();
+    }
+
+    @Test
+    public void cancelledGroupResumesRequesting() {
+        final List> tss = new ArrayList>();
+        final AtomicInteger counter = new AtomicInteger();
+        final AtomicBoolean done = new AtomicBoolean();
+        Flowable.range(1, 1000)
+                .doOnNext(new Consumer() {
+                    @Override
+                    public void accept(Integer v) throws Exception {
+                        counter.getAndIncrement();
+                    }
+                })
+                .groupBy(Functions.justFunction(1))
+                .subscribe(new Consumer>() {
+                    @Override
+                    public void accept(GroupedFlowable v) throws Exception {
+                        TestSubscriber ts = TestSubscriber.create(0L);
+                        tss.add(ts);
+                        v.subscribe(ts);
+                    }
+                }, Functions.emptyConsumer(), new Action() {
+                    @Override
+                    public void run() throws Exception {
+                        done.set(true);
+                    }
+                });
+
+        while (!done.get()) {
+            tss.remove(0).cancel();
+        }
+
+        assertEquals(1000, counter.get());
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableGroupJoinTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableGroupJoinTest.java
index b9e1b4f995..0704878805 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableGroupJoinTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableGroupJoinTest.java
@@ -16,7 +16,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableHideTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableHideTest.java
index af85b261c6..fbc4708710 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableHideTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableHideTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.assertFalse;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import org.junit.Test;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableJoinTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableJoinTest.java
index 14a5ec3d59..e8f71d7aae 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableJoinTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableJoinTest.java
@@ -15,7 +15,6 @@
  */
 package io.reactivex.internal.operators.flowable;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableMapTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableMapTest.java
index 9ebc328d56..0ff960c4cc 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableMapTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableMapTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.assertNull;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
@@ -24,7 +23,6 @@
 import org.reactivestreams.*;
 
 import io.reactivex.*;
-import io.reactivex.Flowable;
 import io.reactivex.exceptions.TestException;
 import io.reactivex.functions.*;
 import io.reactivex.internal.functions.Functions;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeDelayErrorTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeDelayErrorTest.java
index 67129c956b..671abc314e 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeDelayErrorTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeDelayErrorTest.java
@@ -25,7 +25,6 @@
 import org.reactivestreams.*;
 
 import io.reactivex.*;
-import io.reactivex.Flowable;
 import io.reactivex.exceptions.*;
 import io.reactivex.functions.LongConsumer;
 import io.reactivex.internal.subscriptions.BooleanSubscription;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeTest.java
index 010da8bd69..34a732be7c 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeTest.java
@@ -15,7 +15,6 @@
 
 import static java.util.Arrays.asList;
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.lang.reflect.Method;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeWithCompletableTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeWithCompletableTest.java
index cf5b7917a6..18f5551e4a 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeWithCompletableTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeWithCompletableTest.java
@@ -136,4 +136,40 @@ public void run() {
             ts.assertResult(1);
         }
     }
+
+    @Test
+    public void cancelOtherOnMainError() {
+        PublishProcessor pp = PublishProcessor.create();
+        CompletableSubject cs = CompletableSubject.create();
+
+        TestSubscriber ts = pp.mergeWith(cs).test();
+
+        assertTrue(pp.hasSubscribers());
+        assertTrue(cs.hasObservers());
+
+        pp.onError(new TestException());
+
+        ts.assertFailure(TestException.class);
+
+        assertFalse("main has observers!", pp.hasSubscribers());
+        assertFalse("other has observers", cs.hasObservers());
+    }
+
+    @Test
+    public void cancelMainOnOtherError() {
+        PublishProcessor pp = PublishProcessor.create();
+        CompletableSubject cs = CompletableSubject.create();
+
+        TestSubscriber ts = pp.mergeWith(cs).test();
+
+        assertTrue(pp.hasSubscribers());
+        assertTrue(cs.hasObservers());
+
+        cs.onError(new TestException());
+
+        ts.assertFailure(TestException.class);
+
+        assertFalse("main has observers!", pp.hasSubscribers());
+        assertFalse("other has observers", cs.hasObservers());
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeWithMaybeTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeWithMaybeTest.java
index c38bf6ae7b..676c9074c3 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeWithMaybeTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeWithMaybeTest.java
@@ -401,4 +401,40 @@ public void onNext(Integer t) {
         ts.assertValueCount(Flowable.bufferSize());
         ts.assertComplete();
     }
+
+    @Test
+    public void cancelOtherOnMainError() {
+        PublishProcessor pp = PublishProcessor.create();
+        MaybeSubject ms = MaybeSubject.create();
+
+        TestSubscriber ts = pp.mergeWith(ms).test();
+
+        assertTrue(pp.hasSubscribers());
+        assertTrue(ms.hasObservers());
+
+        pp.onError(new TestException());
+
+        ts.assertFailure(TestException.class);
+
+        assertFalse("main has observers!", pp.hasSubscribers());
+        assertFalse("other has observers", ms.hasObservers());
+    }
+
+    @Test
+    public void cancelMainOnOtherError() {
+        PublishProcessor pp = PublishProcessor.create();
+        MaybeSubject ms = MaybeSubject.create();
+
+        TestSubscriber ts = pp.mergeWith(ms).test();
+
+        assertTrue(pp.hasSubscribers());
+        assertTrue(ms.hasObservers());
+
+        ms.onError(new TestException());
+
+        ts.assertFailure(TestException.class);
+
+        assertFalse("main has observers!", pp.hasSubscribers());
+        assertFalse("other has observers", ms.hasObservers());
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeWithSingleTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeWithSingleTest.java
index 2ab0568a7e..6a182785da 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeWithSingleTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableMergeWithSingleTest.java
@@ -397,4 +397,40 @@ public void onNext(Integer t) {
         ts.assertValueCount(Flowable.bufferSize());
         ts.assertComplete();
     }
+
+    @Test
+    public void cancelOtherOnMainError() {
+        PublishProcessor pp = PublishProcessor.create();
+        SingleSubject ss = SingleSubject.create();
+
+        TestSubscriber ts = pp.mergeWith(ss).test();
+
+        assertTrue(pp.hasSubscribers());
+        assertTrue(ss.hasObservers());
+
+        pp.onError(new TestException());
+
+        ts.assertFailure(TestException.class);
+
+        assertFalse("main has observers!", pp.hasSubscribers());
+        assertFalse("other has observers", ss.hasObservers());
+    }
+
+    @Test
+    public void cancelMainOnOtherError() {
+        PublishProcessor pp = PublishProcessor.create();
+        SingleSubject ss = SingleSubject.create();
+
+        TestSubscriber ts = pp.mergeWith(ss).test();
+
+        assertTrue(pp.hasSubscribers());
+        assertTrue(ss.hasObservers());
+
+        ss.onError(new TestException());
+
+        ts.assertFailure(TestException.class);
+
+        assertFalse("main has observers!", pp.hasSubscribers());
+        assertFalse("other has observers", ss.hasObservers());
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableObserveOnTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableObserveOnTest.java
index ca4bd28986..a5abff03ef 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableObserveOnTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableObserveOnTest.java
@@ -35,6 +35,7 @@
 import io.reactivex.internal.operators.flowable.FlowableObserveOn.BaseObserveOnSubscriber;
 import io.reactivex.internal.schedulers.ImmediateThinScheduler;
 import io.reactivex.internal.subscriptions.BooleanSubscription;
+import io.reactivex.observers.TestObserver;
 import io.reactivex.plugins.RxJavaPlugins;
 import io.reactivex.processors.*;
 import io.reactivex.schedulers.*;
@@ -1941,4 +1942,37 @@ public void workerNotDisposedPrematurelyNormalInAsyncOutConditional() {
 
         assertEquals(1, s.disposedCount.get());
     }
+
+    @Test
+    public void fusedNoConcurrentCleanDueToCancel() {
+        for (int j = 0; j < TestHelper.RACE_LONG_LOOPS; j++) {
+            List errors = TestHelper.trackPluginErrors();
+            try {
+                final UnicastProcessor up = UnicastProcessor.create();
+
+                TestObserver to = up.hide()
+                .observeOn(Schedulers.io())
+                .observeOn(Schedulers.single())
+                .unsubscribeOn(Schedulers.computation())
+                .firstOrError()
+                .test();
+
+                for (int i = 0; up.hasSubscribers() && i < 10000; i++) {
+                    up.onNext(i);
+                }
+
+                to
+                .awaitDone(5, TimeUnit.SECONDS)
+                ;
+
+                if (!errors.isEmpty()) {
+                    throw new CompositeException(errors);
+                }
+
+                to.assertResult(0);
+            } finally {
+                RxJavaPlugins.reset();
+            }
+        }
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableOnBackpressureBufferTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableOnBackpressureBufferTest.java
index 84793d3136..be7fe522da 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableOnBackpressureBufferTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableOnBackpressureBufferTest.java
@@ -15,17 +15,22 @@
 
 import static org.junit.Assert.*;
 
+import java.util.List;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.Test;
 import org.reactivestreams.*;
 
-import io.reactivex.Flowable;
+import io.reactivex.*;
 import io.reactivex.exceptions.*;
 import io.reactivex.functions.*;
+import io.reactivex.internal.functions.Functions;
 import io.reactivex.internal.fuseable.QueueFuseable;
 import io.reactivex.internal.subscriptions.BooleanSubscription;
+import io.reactivex.observers.TestObserver;
+import io.reactivex.plugins.RxJavaPlugins;
+import io.reactivex.processors.PublishProcessor;
 import io.reactivex.schedulers.Schedulers;
 import io.reactivex.subscribers.*;
 
@@ -143,7 +148,7 @@ public void run() {
 
         int size = ts.values().size();
         assertTrue(size <= 150);  // will get up to 50 more
-        assertTrue(ts.values().get(size - 1) == size - 1);
+        assertEquals((long)ts.values().get(size - 1), size - 1);
     }
 
     static final Flowable infinite = Flowable.unsafeCreate(new Publisher() {
@@ -307,4 +312,37 @@ public void fusionRejected() {
         SubscriberFusion.assertFusion(ts, QueueFuseable.NONE)
         .assertEmpty();
     }
+
+    @Test
+    public void fusedNoConcurrentCleanDueToCancel() {
+        for (int j = 0; j < TestHelper.RACE_LONG_LOOPS; j++) {
+            List errors = TestHelper.trackPluginErrors();
+            try {
+                final PublishProcessor pp = PublishProcessor.create();
+
+                TestObserver to = pp.onBackpressureBuffer(4, false, true)
+                .observeOn(Schedulers.io())
+                .map(Functions.identity())
+                .observeOn(Schedulers.single())
+                .firstOrError()
+                .test();
+
+                for (int i = 0; pp.hasSubscribers(); i++) {
+                    pp.onNext(i);
+                }
+
+                to
+                .awaitDone(5, TimeUnit.SECONDS)
+                ;
+
+                if (!errors.isEmpty()) {
+                    throw new CompositeException(errors);
+                }
+
+                to.assertResult(0);
+            } finally {
+                RxJavaPlugins.reset();
+            }
+        }
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableOnBackpressureErrorTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableOnBackpressureErrorTest.java
index 3be409e862..9afb864d40 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableOnBackpressureErrorTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableOnBackpressureErrorTest.java
@@ -13,11 +13,16 @@
 
 package io.reactivex.internal.operators.flowable;
 
+import static org.junit.Assert.*;
+
 import org.junit.Test;
 import org.reactivestreams.Publisher;
 
 import io.reactivex.*;
+import io.reactivex.exceptions.MissingBackpressureException;
 import io.reactivex.functions.Function;
+import io.reactivex.subjects.PublishSubject;
+import io.reactivex.subscribers.TestSubscriber;
 
 public class FlowableOnBackpressureErrorTest {
 
@@ -50,4 +55,20 @@ public Object apply(Flowable f) throws Exception {
             }
         }, false, 1, 1, 1);
     }
+
+    @Test
+    public void overflowCancels() {
+        PublishSubject ps = PublishSubject.create();
+
+        TestSubscriber ts = ps.toFlowable(BackpressureStrategy.ERROR)
+        .test(0L);
+
+        assertTrue(ps.hasObservers());
+
+        ps.onNext(1);
+
+        assertFalse(ps.hasObservers());
+
+        ts.assertFailure(MissingBackpressureException.class);
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableOnErrorResumeNextViaFunctionTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableOnErrorResumeNextViaFunctionTest.java
index 06f10e835d..8d3cef82d0 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableOnErrorResumeNextViaFunctionTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableOnErrorResumeNextViaFunctionTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowablePublishAltTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowablePublishAltTest.java
new file mode 100644
index 0000000000..414aa79c07
--- /dev/null
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowablePublishAltTest.java
@@ -0,0 +1,1629 @@
+/**
+ * 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.internal.operators.flowable;
+
+import static org.junit.Assert.*;
+
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
+
+import org.junit.*;
+import org.reactivestreams.*;
+
+import io.reactivex.*;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.*;
+import io.reactivex.flowables.ConnectableFlowable;
+import io.reactivex.functions.*;
+import io.reactivex.internal.functions.Functions;
+import io.reactivex.internal.fuseable.HasUpstreamPublisher;
+import io.reactivex.internal.operators.flowable.FlowablePublish.*;
+import io.reactivex.internal.schedulers.ImmediateThinScheduler;
+import io.reactivex.internal.subscriptions.BooleanSubscription;
+import io.reactivex.plugins.RxJavaPlugins;
+import io.reactivex.processors.PublishProcessor;
+import io.reactivex.schedulers.*;
+import io.reactivex.subscribers.TestSubscriber;
+
+public class FlowablePublishAltTest {
+
+    @Test
+    public void testPublish() throws InterruptedException {
+        final AtomicInteger counter = new AtomicInteger();
+        ConnectableFlowable f = Flowable.unsafeCreate(new Publisher() {
+
+            @Override
+            public void subscribe(final Subscriber subscriber) {
+                subscriber.onSubscribe(new BooleanSubscription());
+                new Thread(new Runnable() {
+
+                    @Override
+                    public void run() {
+                        counter.incrementAndGet();
+                        subscriber.onNext("one");
+                        subscriber.onComplete();
+                    }
+                }).start();
+            }
+        }).publish();
+
+        final CountDownLatch latch = new CountDownLatch(2);
+
+        // subscribe once
+        f.subscribe(new Consumer() {
+
+            @Override
+            public void accept(String v) {
+                assertEquals("one", v);
+                latch.countDown();
+            }
+        });
+
+        // subscribe again
+        f.subscribe(new Consumer() {
+
+            @Override
+            public void accept(String v) {
+                assertEquals("one", v);
+                latch.countDown();
+            }
+        });
+
+        Disposable connection = f.connect();
+        try {
+            if (!latch.await(1000, TimeUnit.MILLISECONDS)) {
+                fail("subscriptions did not receive values");
+            }
+            assertEquals(1, counter.get());
+        } finally {
+            connection.dispose();
+        }
+    }
+
+    @Test
+    public void testBackpressureFastSlow() {
+        ConnectableFlowable is = Flowable.range(1, Flowable.bufferSize() * 2).publish();
+        Flowable fast = is.observeOn(Schedulers.computation())
+        .doOnComplete(new Action() {
+            @Override
+            public void run() {
+                System.out.println("^^^^^^^^^^^^^ completed FAST");
+            }
+        });
+
+        Flowable slow = is.observeOn(Schedulers.computation()).map(new Function() {
+            int c;
+
+            @Override
+            public Integer apply(Integer i) {
+                if (c == 0) {
+                    try {
+                        Thread.sleep(500);
+                    } catch (InterruptedException e) {
+                    }
+                }
+                c++;
+                return i;
+            }
+
+        }).doOnComplete(new Action() {
+
+            @Override
+            public void run() {
+                System.out.println("^^^^^^^^^^^^^ completed SLOW");
+            }
+
+        });
+
+        TestSubscriber ts = new TestSubscriber();
+        Flowable.merge(fast, slow).subscribe(ts);
+        is.connect();
+        ts.awaitTerminalEvent();
+        ts.assertNoErrors();
+        assertEquals(Flowable.bufferSize() * 4, ts.valueCount());
+    }
+
+    // use case from https://github.com/ReactiveX/RxJava/issues/1732
+    @Test
+    public void testTakeUntilWithPublishedStreamUsingSelector() {
+        final AtomicInteger emitted = new AtomicInteger();
+        Flowable xs = Flowable.range(0, Flowable.bufferSize() * 2).doOnNext(new Consumer() {
+
+            @Override
+            public void accept(Integer t1) {
+                emitted.incrementAndGet();
+            }
+
+        });
+        TestSubscriber ts = new TestSubscriber();
+        xs.publish(new Function, Flowable>() {
+
+            @Override
+            public Flowable apply(Flowable xs) {
+                return xs.takeUntil(xs.skipWhile(new Predicate() {
+
+                    @Override
+                    public boolean test(Integer i) {
+                        return i <= 3;
+                    }
+
+                }));
+            }
+
+        }).subscribe(ts);
+        ts.awaitTerminalEvent();
+        ts.assertNoErrors();
+        ts.assertValues(0, 1, 2, 3);
+        assertEquals(5, emitted.get());
+        System.out.println(ts.values());
+    }
+
+    // use case from https://github.com/ReactiveX/RxJava/issues/1732
+    @Test
+    public void testTakeUntilWithPublishedStream() {
+        Flowable xs = Flowable.range(0, Flowable.bufferSize() * 2);
+        TestSubscriber ts = new TestSubscriber();
+        ConnectableFlowable xsp = xs.publish();
+        xsp.takeUntil(xsp.skipWhile(new Predicate() {
+
+            @Override
+            public boolean test(Integer i) {
+                return i <= 3;
+            }
+
+        })).subscribe(ts);
+        xsp.connect();
+        System.out.println(ts.values());
+    }
+
+    @Test(timeout = 10000)
+    public void testBackpressureTwoConsumers() {
+        final AtomicInteger sourceEmission = new AtomicInteger();
+        final AtomicBoolean sourceUnsubscribed = new AtomicBoolean();
+        final Flowable source = Flowable.range(1, 100)
+                .doOnNext(new Consumer() {
+                    @Override
+                    public void accept(Integer t1) {
+                        sourceEmission.incrementAndGet();
+                    }
+                })
+                .doOnCancel(new Action() {
+                    @Override
+                    public void run() {
+                        sourceUnsubscribed.set(true);
+                    }
+                }).share();
+        ;
+
+        final AtomicBoolean child1Unsubscribed = new AtomicBoolean();
+        final AtomicBoolean child2Unsubscribed = new AtomicBoolean();
+
+        final TestSubscriber ts2 = new TestSubscriber();
+
+        final TestSubscriber ts1 = new TestSubscriber() {
+            @Override
+            public void onNext(Integer t) {
+                if (valueCount() == 2) {
+                    source.doOnCancel(new Action() {
+                        @Override
+                        public void run() {
+                            child2Unsubscribed.set(true);
+                        }
+                    }).take(5).subscribe(ts2);
+                }
+                super.onNext(t);
+            }
+        };
+
+        source.doOnCancel(new Action() {
+            @Override
+            public void run() {
+                child1Unsubscribed.set(true);
+            }
+        }).take(5)
+        .subscribe(ts1);
+
+        ts1.awaitTerminalEvent();
+        ts2.awaitTerminalEvent();
+
+        ts1.assertNoErrors();
+        ts2.assertNoErrors();
+
+        assertTrue(sourceUnsubscribed.get());
+        assertTrue(child1Unsubscribed.get());
+        assertTrue(child2Unsubscribed.get());
+
+        ts1.assertValues(1, 2, 3, 4, 5);
+        ts2.assertValues(4, 5, 6, 7, 8);
+
+        assertEquals(8, sourceEmission.get());
+    }
+
+    @Test
+    public void testConnectWithNoSubscriber() {
+        TestScheduler scheduler = new TestScheduler();
+        ConnectableFlowable cf = Flowable.interval(10, 10, TimeUnit.MILLISECONDS, scheduler).take(3).publish();
+        cf.connect();
+        // Emit 0
+        scheduler.advanceTimeBy(15, TimeUnit.MILLISECONDS);
+        TestSubscriber subscriber = new TestSubscriber();
+        cf.subscribe(subscriber);
+        // Emit 1 and 2
+        scheduler.advanceTimeBy(50, TimeUnit.MILLISECONDS);
+        subscriber.assertValues(1L, 2L);
+        subscriber.assertNoErrors();
+        subscriber.assertTerminated();
+    }
+
+    @Test
+    public void testSubscribeAfterDisconnectThenConnect() {
+        ConnectableFlowable source = Flowable.just(1).publish();
+
+        TestSubscriber ts1 = new TestSubscriber();
+
+        source.subscribe(ts1);
+
+        Disposable connection = source.connect();
+
+        ts1.assertValue(1);
+        ts1.assertNoErrors();
+        ts1.assertTerminated();
+
+        TestSubscriber ts2 = new TestSubscriber();
+
+        source.subscribe(ts2);
+
+        Disposable connection2 = source.connect();
+
+        ts2.assertValue(1);
+        ts2.assertNoErrors();
+        ts2.assertTerminated();
+
+        System.out.println(connection);
+        System.out.println(connection2);
+    }
+
+    @Test
+    public void testNoSubscriberRetentionOnCompleted() {
+        FlowablePublish source = (FlowablePublish)Flowable.just(1).publish();
+
+        TestSubscriber ts1 = new TestSubscriber();
+
+        source.subscribe(ts1);
+
+        ts1.assertNoValues();
+        ts1.assertNoErrors();
+        ts1.assertNotComplete();
+
+        source.connect();
+
+        ts1.assertValue(1);
+        ts1.assertNoErrors();
+        ts1.assertTerminated();
+
+        assertNull(source.current.get());
+    }
+
+    @Test
+    public void testNonNullConnection() {
+        ConnectableFlowable source = Flowable.never().publish();
+
+        assertNotNull(source.connect());
+        assertNotNull(source.connect());
+    }
+
+    @Test
+    public void testNoDisconnectSomeoneElse() {
+        ConnectableFlowable source = Flowable.never().publish();
+
+        Disposable connection1 = source.connect();
+        Disposable connection2 = source.connect();
+
+        connection1.dispose();
+
+        Disposable connection3 = source.connect();
+
+        connection2.dispose();
+
+        assertTrue(checkPublishDisposed(connection1));
+        assertTrue(checkPublishDisposed(connection2));
+        assertFalse(checkPublishDisposed(connection3));
+    }
+
+    @SuppressWarnings("unchecked")
+    static boolean checkPublishDisposed(Disposable d) {
+        return ((FlowablePublish.PublishSubscriber)d).isDisposed();
+    }
+
+    @Test
+    public void testZeroRequested() {
+        ConnectableFlowable source = Flowable.just(1).publish();
+
+        TestSubscriber ts = new TestSubscriber(0L);
+
+        source.subscribe(ts);
+
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotComplete();
+
+        source.connect();
+
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotComplete();
+
+        ts.request(5);
+
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertTerminated();
+    }
+
+    @Test
+    public void testConnectIsIdempotent() {
+        final AtomicInteger calls = new AtomicInteger();
+        Flowable source = Flowable.unsafeCreate(new Publisher() {
+            @Override
+            public void subscribe(Subscriber t) {
+                t.onSubscribe(new BooleanSubscription());
+                calls.getAndIncrement();
+            }
+        });
+
+        ConnectableFlowable conn = source.publish();
+
+        assertEquals(0, calls.get());
+
+        conn.connect();
+        conn.connect();
+
+        assertEquals(1, calls.get());
+
+        conn.connect().dispose();
+
+        conn.connect();
+        conn.connect();
+
+        assertEquals(2, calls.get());
+    }
+
+    @Test
+    public void syncFusedObserveOn() {
+        ConnectableFlowable cf = Flowable.range(0, 1000).publish();
+        Flowable obs = cf.observeOn(Schedulers.computation());
+        for (int i = 0; i < 1000; i++) {
+            for (int j = 1; j < 6; j++) {
+                List> tss = new ArrayList>();
+                for (int k = 1; k < j; k++) {
+                    TestSubscriber ts = new TestSubscriber();
+                    tss.add(ts);
+                    obs.subscribe(ts);
+                }
+
+                Disposable connection = cf.connect();
+
+                for (TestSubscriber ts : tss) {
+                    ts.awaitDone(5, TimeUnit.SECONDS)
+                    .assertSubscribed()
+                    .assertValueCount(1000)
+                    .assertNoErrors()
+                    .assertComplete();
+                }
+                connection.dispose();
+            }
+        }
+    }
+
+    @Test
+    public void syncFusedObserveOn2() {
+        ConnectableFlowable cf = Flowable.range(0, 1000).publish();
+        Flowable obs = cf.observeOn(ImmediateThinScheduler.INSTANCE);
+        for (int i = 0; i < 1000; i++) {
+            for (int j = 1; j < 6; j++) {
+                List> tss = new ArrayList>();
+                for (int k = 1; k < j; k++) {
+                    TestSubscriber ts = new TestSubscriber();
+                    tss.add(ts);
+                    obs.subscribe(ts);
+                }
+
+                Disposable connection = cf.connect();
+
+                for (TestSubscriber ts : tss) {
+                    ts.awaitDone(5, TimeUnit.SECONDS)
+                    .assertSubscribed()
+                    .assertValueCount(1000)
+                    .assertNoErrors()
+                    .assertComplete();
+                }
+                connection.dispose();
+            }
+        }
+    }
+
+    @Test
+    public void asyncFusedObserveOn() {
+        ConnectableFlowable cf = Flowable.range(0, 1000).observeOn(ImmediateThinScheduler.INSTANCE).publish();
+        for (int i = 0; i < 1000; i++) {
+            for (int j = 1; j < 6; j++) {
+                List> tss = new ArrayList>();
+                for (int k = 1; k < j; k++) {
+                    TestSubscriber ts = new TestSubscriber();
+                    tss.add(ts);
+                    cf.subscribe(ts);
+                }
+
+                Disposable connection = cf.connect();
+
+                for (TestSubscriber ts : tss) {
+                    ts.awaitDone(5, TimeUnit.SECONDS)
+                    .assertSubscribed()
+                    .assertValueCount(1000)
+                    .assertNoErrors()
+                    .assertComplete();
+                }
+                connection.dispose();
+            }
+        }
+    }
+
+    @Test
+    public void testObserveOn() {
+        ConnectableFlowable cf = Flowable.range(0, 1000).hide().publish();
+        Flowable obs = cf.observeOn(Schedulers.computation());
+        for (int i = 0; i < 1000; i++) {
+            for (int j = 1; j < 6; j++) {
+                List> tss = new ArrayList>();
+                for (int k = 1; k < j; k++) {
+                    TestSubscriber ts = new TestSubscriber();
+                    tss.add(ts);
+                    obs.subscribe(ts);
+                }
+
+                Disposable connection = cf.connect();
+
+                for (TestSubscriber ts : tss) {
+                    ts.awaitDone(5, TimeUnit.SECONDS)
+                    .assertSubscribed()
+                    .assertValueCount(1000)
+                    .assertNoErrors()
+                    .assertComplete();
+                }
+                connection.dispose();
+            }
+        }
+    }
+
+    @Test
+    public void source() {
+        Flowable f = Flowable.never();
+
+        assertSame(f, (((HasUpstreamPublisher)f.publish()).source()));
+    }
+
+    @Test
+    public void connectThrows() {
+        ConnectableFlowable cf = Flowable.empty().publish();
+        try {
+            cf.connect(new Consumer() {
+                @Override
+                public void accept(Disposable d) throws Exception {
+                    throw new TestException();
+                }
+            });
+        } catch (TestException ex) {
+            // expected
+        }
+    }
+
+    @Test
+    public void addRemoveRace() {
+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+
+            final ConnectableFlowable cf = Flowable.empty().publish();
+
+            final TestSubscriber ts = cf.test();
+
+            final TestSubscriber ts2 = new TestSubscriber();
+
+            Runnable r1 = new Runnable() {
+                @Override
+                public void run() {
+                    cf.subscribe(ts2);
+                }
+            };
+
+            Runnable r2 = new Runnable() {
+                @Override
+                public void run() {
+                    ts.cancel();
+                }
+            };
+
+            TestHelper.race(r1, r2);
+        }
+    }
+
+    @Test
+    public void disposeOnArrival() {
+        ConnectableFlowable cf = Flowable.empty().publish();
+
+        cf.test(Long.MAX_VALUE, true).assertEmpty();
+    }
+
+    @Test
+    public void disposeOnArrival2() {
+        Flowable co = Flowable.never().publish().autoConnect();
+
+        co.test(Long.MAX_VALUE, true).assertEmpty();
+    }
+
+    @Test
+    public void dispose() {
+        TestHelper.checkDisposed(Flowable.never().publish());
+
+        TestHelper.checkDisposed(Flowable.never().publish(Functions.>identity()));
+    }
+
+    @Test
+    public void empty() {
+        ConnectableFlowable cf = Flowable.empty().publish();
+
+        cf.connect();
+    }
+
+    @Test
+    public void take() {
+        ConnectableFlowable cf = Flowable.range(1, 2).publish();
+
+        TestSubscriber ts = cf.take(1).test();
+
+        cf.connect();
+
+        ts.assertResult(1);
+    }
+
+    @Test
+    public void just() {
+        final PublishProcessor pp = PublishProcessor.create();
+
+        ConnectableFlowable cf = pp.publish();
+
+        TestSubscriber ts = new TestSubscriber() {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                pp.onComplete();
+            }
+        };
+
+        cf.subscribe(ts);
+        cf.connect();
+
+        pp.onNext(1);
+
+        ts.assertResult(1);
+    }
+
+    @Test
+    public void nextCancelRace() {
+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+
+            final PublishProcessor pp = PublishProcessor.create();
+
+            final ConnectableFlowable cf = pp.publish();
+
+            final TestSubscriber ts = cf.test();
+
+            Runnable r1 = new Runnable() {
+                @Override
+                public void run() {
+                    pp.onNext(1);
+                }
+            };
+
+            Runnable r2 = new Runnable() {
+                @Override
+                public void run() {
+                    ts.cancel();
+                }
+            };
+
+            TestHelper.race(r1, r2);
+        }
+    }
+
+    @Test
+    public void badSource() {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            new Flowable() {
+                @Override
+                protected void subscribeActual(Subscriber subscriber) {
+                    subscriber.onSubscribe(new BooleanSubscription());
+                    subscriber.onNext(1);
+                    subscriber.onComplete();
+                    subscriber.onNext(2);
+                    subscriber.onError(new TestException());
+                    subscriber.onComplete();
+                }
+            }
+            .publish()
+            .autoConnect()
+            .test()
+            .assertResult(1);
+
+            TestHelper.assertUndeliverable(errors, 0, TestException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    @Test
+    public void noErrorLoss() {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            ConnectableFlowable cf = Flowable.error(new TestException()).publish();
+
+            cf.connect();
+
+            TestHelper.assertUndeliverable(errors, 0, TestException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    @Test
+    public void subscribeDisconnectRace() {
+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+
+            final PublishProcessor pp = PublishProcessor.create();
+
+            final ConnectableFlowable cf = pp.publish();
+
+            final Disposable d = cf.connect();
+            final TestSubscriber ts = new TestSubscriber();
+
+            Runnable r1 = new Runnable() {
+                @Override
+                public void run() {
+                    d.dispose();
+                }
+            };
+
+            Runnable r2 = new Runnable() {
+                @Override
+                public void run() {
+                    cf.subscribe(ts);
+                }
+            };
+
+            TestHelper.race(r1, r2);
+        }
+    }
+
+    @Test
+    public void selectorDisconnectsIndependentSource() {
+        PublishProcessor pp = PublishProcessor.create();
+
+        pp.publish(new Function, Flowable>() {
+            @Override
+            public Flowable apply(Flowable v) throws Exception {
+                return Flowable.range(1, 2);
+            }
+        })
+        .test()
+        .assertResult(1, 2);
+
+        assertFalse(pp.hasSubscribers());
+    }
+
+    @Test(timeout = 5000)
+    public void selectorLatecommer() {
+        Flowable.range(1, 5)
+        .publish(new Function, Flowable>() {
+            @Override
+            public Flowable apply(Flowable v) throws Exception {
+                return v.concatWith(v);
+            }
+        })
+        .test()
+        .assertResult(1, 2, 3, 4, 5);
+    }
+
+    @Test
+    public void mainError() {
+        Flowable.error(new TestException())
+        .publish(Functions.>identity())
+        .test()
+        .assertFailure(TestException.class);
+    }
+
+    @Test
+    public void selectorInnerError() {
+        PublishProcessor pp = PublishProcessor.create();
+
+        pp.publish(new Function, Flowable>() {
+            @Override
+            public Flowable apply(Flowable v) throws Exception {
+                return Flowable.error(new TestException());
+            }
+        })
+        .test()
+        .assertFailure(TestException.class);
+
+        assertFalse(pp.hasSubscribers());
+    }
+
+    @Test
+    public void preNextConnect() {
+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+
+            final ConnectableFlowable cf = Flowable.empty().publish();
+
+            cf.connect();
+
+            Runnable r1 = new Runnable() {
+                @Override
+                public void run() {
+                    cf.test();
+                }
+            };
+
+            TestHelper.race(r1, r1);
+        }
+    }
+
+    @Test
+    public void connectRace() {
+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+
+            final ConnectableFlowable cf = Flowable.empty().publish();
+
+            Runnable r1 = new Runnable() {
+                @Override
+                public void run() {
+                    cf.connect();
+                }
+            };
+
+            TestHelper.race(r1, r1);
+        }
+    }
+
+    @Test
+    public void selectorCrash() {
+        Flowable.just(1).publish(new Function, Flowable>() {
+            @Override
+            public Flowable apply(Flowable v) throws Exception {
+                throw new TestException();
+            }
+        })
+        .test()
+        .assertFailure(TestException.class);
+    }
+
+    @Test
+    public void pollThrows() {
+        Flowable.just(1)
+        .map(new Function() {
+            @Override
+            public Object apply(Integer v) throws Exception {
+                throw new TestException();
+            }
+        })
+        .compose(TestHelper.flowableStripBoundary())
+        .publish()
+        .autoConnect()
+        .test()
+        .assertFailure(TestException.class);
+    }
+
+    @Test
+    public void pollThrowsNoSubscribers() {
+        ConnectableFlowable cf = Flowable.just(1, 2)
+        .map(new Function() {
+            @Override
+            public Integer apply(Integer v) throws Exception {
+                if (v == 2) {
+                    throw new TestException();
+                }
+                return v;
+            }
+        })
+        .compose(TestHelper.flowableStripBoundary())
+        .publish();
+
+        TestSubscriber ts = cf.take(1)
+        .test();
+
+        cf.connect();
+
+        ts.assertResult(1);
+    }
+
+    @Test
+    public void dryRunCrash() {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            final TestSubscriber ts = new TestSubscriber(1L) {
+                @Override
+                public void onNext(Object t) {
+                    super.onNext(t);
+                    onComplete();
+                    cancel();
+                }
+            };
+
+            Flowable.range(1, 10)
+            .map(new Function() {
+                @Override
+                public Object apply(Integer v) throws Exception {
+                    if (v == 2) {
+                        throw new TestException();
+                    }
+                    return v;
+                }
+            })
+            .publish()
+            .autoConnect()
+            .subscribe(ts);
+
+            ts
+            .assertResult(1);
+
+            TestHelper.assertUndeliverable(errors, 0, TestException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    @Test
+    public void overflowQueue() {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            Flowable.create(new FlowableOnSubscribe() {
+                @Override
+                public void subscribe(FlowableEmitter s) throws Exception {
+                    for (int i = 0; i < 10; i++) {
+                        s.onNext(i);
+                    }
+                }
+            }, BackpressureStrategy.MISSING)
+            .publish(8)
+            .autoConnect()
+            .test(0L)
+           .assertFailure(MissingBackpressureException.class);
+
+            TestHelper.assertError(errors, 0, MissingBackpressureException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    @Test
+    public void delayedUpstreamOnSubscribe() {
+        final Subscriber[] sub = { null };
+
+        new Flowable() {
+            @Override
+            protected void subscribeActual(Subscriber s) {
+                sub[0] = s;
+            }
+        }
+        .publish()
+        .connect()
+        .dispose();
+
+        BooleanSubscription bs = new BooleanSubscription();
+
+        sub[0].onSubscribe(bs);
+
+        assertTrue(bs.isCancelled());
+    }
+
+    @Test
+    public void disposeRace() {
+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+
+            final AtomicReference ref = new AtomicReference();
+
+            final ConnectableFlowable cf = new Flowable() {
+                @Override
+                protected void subscribeActual(Subscriber s) {
+                    s.onSubscribe(new BooleanSubscription());
+                    ref.set((Disposable)s);
+                }
+            }.publish();
+
+            cf.connect();
+
+            Runnable r1 = new Runnable() {
+                @Override
+                public void run() {
+                    ref.get().dispose();
+                }
+            };
+
+            TestHelper.race(r1, r1);
+        }
+    }
+
+    @Test
+    public void removeNotPresent() {
+        final AtomicReference> ref = new AtomicReference>();
+
+        final ConnectableFlowable cf = new Flowable() {
+            @Override
+            @SuppressWarnings("unchecked")
+            protected void subscribeActual(Subscriber s) {
+                s.onSubscribe(new BooleanSubscription());
+                ref.set((PublishSubscriber)s);
+            }
+        }.publish();
+
+        cf.connect();
+
+        ref.get().add(new InnerSubscriber(new TestSubscriber()));
+        ref.get().remove(null);
+    }
+
+    @Test
+    @Ignore("publish() keeps consuming the upstream if there are no subscribers, 3.x should change this")
+    public void subscriberSwap() {
+        final ConnectableFlowable cf = Flowable.range(1, 5).publish();
+
+        cf.connect();
+
+        TestSubscriber ts1 = new TestSubscriber() {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                cancel();
+                onComplete();
+            }
+        };
+
+        cf.subscribe(ts1);
+
+        ts1.assertResult(1);
+
+        TestSubscriber ts2 = new TestSubscriber(0);
+        cf.subscribe(ts2);
+
+        ts2
+        .assertEmpty()
+        .requestMore(4)
+        .assertResult(2, 3, 4, 5);
+    }
+
+    @Test
+    public void subscriberLiveSwap() {
+        final ConnectableFlowable cf = new FlowablePublishAlt(Flowable.range(1, 5), 128);
+
+        final TestSubscriber ts2 = new TestSubscriber(0);
+
+        TestSubscriber ts1 = new TestSubscriber() {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                cancel();
+                onComplete();
+                cf.subscribe(ts2);
+            }
+        };
+
+        cf.subscribe(ts1);
+
+        cf.connect();
+
+        ts1.assertResult(1);
+
+        ts2
+        .assertEmpty()
+        .requestMore(4)
+        .assertResult(2, 3, 4, 5);
+    }
+
+    @Test
+    public void selectorSubscriberSwap() {
+        final AtomicReference> ref = new AtomicReference>();
+
+        Flowable.range(1, 5).publish(new Function, Publisher>() {
+            @Override
+            public Publisher apply(Flowable f) throws Exception {
+                ref.set(f);
+                return Flowable.never();
+            }
+        }).test();
+
+        ref.get().take(2).test().assertResult(1, 2);
+
+        ref.get()
+        .test(0)
+        .assertEmpty()
+        .requestMore(2)
+        .assertValuesOnly(3, 4)
+        .requestMore(1)
+        .assertResult(3, 4, 5);
+    }
+
+    @Test
+    public void leavingSubscriberOverrequests() {
+        final AtomicReference> ref = new AtomicReference>();
+
+        PublishProcessor pp = PublishProcessor.create();
+
+        pp.publish(new Function, Publisher>() {
+            @Override
+            public Publisher apply(Flowable f) throws Exception {
+                ref.set(f);
+                return Flowable.never();
+            }
+        }).test();
+
+        TestSubscriber ts1 = ref.get().take(2).test();
+
+        pp.onNext(1);
+        pp.onNext(2);
+
+        ts1.assertResult(1, 2);
+
+        pp.onNext(3);
+        pp.onNext(4);
+
+        TestSubscriber ts2 = ref.get().test(0L);
+
+        ts2.assertEmpty();
+
+        ts2.requestMore(2);
+
+        ts2.assertValuesOnly(3, 4);
+    }
+
+    // call a transformer only if the input is non-empty
+    @Test
+    public void composeIfNotEmpty() {
+        final FlowableTransformer transformer = new FlowableTransformer() {
+            @Override
+            public Publisher apply(Flowable g) {
+                return g.map(new Function() {
+                    @Override
+                    public Integer apply(Integer v) throws Exception {
+                        return v + 1;
+                    }
+                });
+            }
+        };
+
+        final AtomicInteger calls = new AtomicInteger();
+        Flowable.range(1, 5)
+        .publish(new Function, Publisher>() {
+            @Override
+            public Publisher apply(final Flowable shared)
+                    throws Exception {
+                return shared.take(1).concatMap(new Function>() {
+                    @Override
+                    public Publisher apply(Integer first)
+                            throws Exception {
+                        calls.incrementAndGet();
+                        return transformer.apply(Flowable.just(first).concatWith(shared));
+                    }
+                });
+            }
+        })
+        .test()
+        .assertResult(2, 3, 4, 5, 6);
+
+        assertEquals(1, calls.get());
+    }
+
+    // call a transformer only if the input is non-empty
+    @Test
+    public void composeIfNotEmptyNotFused() {
+        final FlowableTransformer transformer = new FlowableTransformer() {
+            @Override
+            public Publisher apply(Flowable g) {
+                return g.map(new Function() {
+                    @Override
+                    public Integer apply(Integer v) throws Exception {
+                        return v + 1;
+                    }
+                });
+            }
+        };
+
+        final AtomicInteger calls = new AtomicInteger();
+        Flowable.range(1, 5).hide()
+        .publish(new Function, Publisher>() {
+            @Override
+            public Publisher apply(final Flowable shared)
+                    throws Exception {
+                return shared.take(1).concatMap(new Function>() {
+                    @Override
+                    public Publisher apply(Integer first)
+                            throws Exception {
+                        calls.incrementAndGet();
+                        return transformer.apply(Flowable.just(first).concatWith(shared));
+                    }
+                });
+            }
+        })
+        .test()
+        .assertResult(2, 3, 4, 5, 6);
+
+        assertEquals(1, calls.get());
+    }
+
+    // call a transformer only if the input is non-empty
+    @Test
+    public void composeIfNotEmptyIsEmpty() {
+        final FlowableTransformer transformer = new FlowableTransformer() {
+            @Override
+            public Publisher apply(Flowable g) {
+                return g.map(new Function() {
+                    @Override
+                    public Integer apply(Integer v) throws Exception {
+                        return v + 1;
+                    }
+                });
+            }
+        };
+
+        final AtomicInteger calls = new AtomicInteger();
+        Flowable.empty().hide()
+        .publish(new Function, Publisher>() {
+            @Override
+            public Publisher apply(final Flowable shared)
+                    throws Exception {
+                return shared.take(1).concatMap(new Function>() {
+                    @Override
+                    public Publisher apply(Integer first)
+                            throws Exception {
+                        calls.incrementAndGet();
+                        return transformer.apply(Flowable.just(first).concatWith(shared));
+                    }
+                });
+            }
+        })
+        .test()
+        .assertResult();
+
+        assertEquals(0, calls.get());
+    }
+
+    @Test
+    public void publishFunctionCancelOuterAfterOneInner() {
+        final AtomicReference> ref = new AtomicReference>();
+
+        PublishProcessor pp = PublishProcessor.create();
+
+        final TestSubscriber ts = pp.publish(new Function, Publisher>() {
+            @Override
+            public Publisher apply(Flowable f) throws Exception {
+                ref.set(f);
+                return Flowable.never();
+            }
+        }).test();
+
+        ref.get().subscribe(new TestSubscriber() {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                onComplete();
+                ts.cancel();
+            }
+        });
+
+        pp.onNext(1);
+    }
+
+    @Test
+    public void publishFunctionCancelOuterAfterOneInnerBackpressured() {
+        final AtomicReference> ref = new AtomicReference>();
+
+        PublishProcessor pp = PublishProcessor.create();
+
+        final TestSubscriber ts = pp.publish(new Function, Publisher>() {
+            @Override
+            public Publisher apply(Flowable f) throws Exception {
+                ref.set(f);
+                return Flowable.never();
+            }
+        }).test();
+
+        ref.get().subscribe(new TestSubscriber(1L) {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                onComplete();
+                ts.cancel();
+            }
+        });
+
+        pp.onNext(1);
+    }
+
+    @Test
+    public void publishCancelOneAsync() {
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+
+            final PublishProcessor pp = PublishProcessor.create();
+
+            final AtomicReference> ref = new AtomicReference>();
+
+            pp.publish(new Function, Publisher>() {
+                @Override
+                public Publisher apply(Flowable f) throws Exception {
+                    ref.set(f);
+                    return Flowable.never();
+                }
+            }).test();
+
+            final TestSubscriber ts1 = ref.get().test();
+            TestSubscriber ts2 = ref.get().test();
+
+            Runnable r1 = new Runnable() {
+                @Override
+                public void run() {
+                    pp.onNext(1);
+                }
+            };
+
+            Runnable r2 = new Runnable() {
+                @Override
+                public void run() {
+                    ts1.cancel();
+                }
+            };
+
+            TestHelper.race(r1, r2);
+
+            ts2.assertValuesOnly(1);
+        }
+    }
+
+    @Test
+    public void publishCancelOneAsync2() {
+        final PublishProcessor pp = PublishProcessor.create();
+
+        ConnectableFlowable cf = pp.publish();
+
+        final TestSubscriber ts1 = new TestSubscriber();
+
+        final AtomicReference> ref = new AtomicReference>();
+
+        cf.subscribe(new FlowableSubscriber() {
+            @SuppressWarnings("unchecked")
+            @Override
+            public void onSubscribe(Subscription s) {
+                ts1.onSubscribe(new BooleanSubscription());
+                // pretend to be cancelled without removing it from the subscriber list
+                ref.set((InnerSubscriber)s);
+            }
+
+            @Override
+            public void onNext(Integer t) {
+                ts1.onNext(t);
+            }
+
+            @Override
+            public void onError(Throwable t) {
+                ts1.onError(t);
+            }
+
+            @Override
+            public void onComplete() {
+                ts1.onComplete();
+            }
+        });
+        TestSubscriber ts2 = cf.test();
+
+        cf.connect();
+
+        ref.get().set(Long.MIN_VALUE);
+
+        pp.onNext(1);
+
+        ts1.assertEmpty();
+        ts2.assertValuesOnly(1);
+    }
+
+    @Test
+    public void boundaryFusion() {
+        Flowable.range(1, 10000)
+        .observeOn(Schedulers.single())
+        .map(new Function() {
+            @Override
+            public String apply(Integer t) throws Exception {
+                String name = Thread.currentThread().getName();
+                if (name.contains("RxSingleScheduler")) {
+                    return "RxSingleScheduler";
+                }
+                return name;
+            }
+        })
+        .share()
+        .observeOn(Schedulers.computation())
+        .distinct()
+        .test()
+        .awaitDone(5, TimeUnit.SECONDS)
+        .assertResult("RxSingleScheduler");
+    }
+
+    @Test
+    public void badRequest() {
+        TestHelper.assertBadRequestReported(Flowable.range(1, 5).publish());
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void splitCombineSubscriberChangeAfterOnNext() {
+        Flowable source = Flowable.range(0, 20)
+        .doOnSubscribe(new Consumer() {
+            @Override
+            public void accept(Subscription v) throws Exception {
+                System.out.println("Subscribed");
+            }
+        })
+        .publish(10)
+        .refCount()
+        ;
+
+        Flowable evenNumbers = source.filter(new Predicate() {
+            @Override
+            public boolean test(Integer v) throws Exception {
+                return v % 2 == 0;
+            }
+        });
+
+        Flowable oddNumbers = source.filter(new Predicate() {
+            @Override
+            public boolean test(Integer v) throws Exception {
+                return v % 2 != 0;
+            }
+        });
+
+        final Single getNextOdd = oddNumbers.first(0);
+
+        TestSubscriber> ts = evenNumbers.concatMap(new Function>>() {
+            @Override
+            public Publisher> apply(Integer v) throws Exception {
+                return Single.zip(
+                        Single.just(v), getNextOdd,
+                        new BiFunction>() {
+                            @Override
+                            public List apply(Integer a, Integer b) throws Exception {
+                                return Arrays.asList( a, b );
+                            }
+                        }
+                )
+                .toFlowable();
+            }
+        })
+        .takeWhile(new Predicate>() {
+            @Override
+            public boolean test(List v) throws Exception {
+                return v.get(0) < 20;
+            }
+        })
+        .test();
+
+        ts
+        .assertResult(
+                Arrays.asList(0, 1),
+                Arrays.asList(2, 3),
+                Arrays.asList(4, 5),
+                Arrays.asList(6, 7),
+                Arrays.asList(8, 9),
+                Arrays.asList(10, 11),
+                Arrays.asList(12, 13),
+                Arrays.asList(14, 15),
+                Arrays.asList(16, 17),
+                Arrays.asList(18, 19)
+        );
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void splitCombineSubscriberChangeAfterOnNextFused() {
+        Flowable source = Flowable.range(0, 20)
+        .publish(10)
+        .refCount()
+        ;
+
+        Flowable evenNumbers = source.filter(new Predicate() {
+            @Override
+            public boolean test(Integer v) throws Exception {
+                return v % 2 == 0;
+            }
+        });
+
+        Flowable oddNumbers = source.filter(new Predicate() {
+            @Override
+            public boolean test(Integer v) throws Exception {
+                return v % 2 != 0;
+            }
+        });
+
+        final Single getNextOdd = oddNumbers.first(0);
+
+        TestSubscriber> ts = evenNumbers.concatMap(new Function>>() {
+            @Override
+            public Publisher> apply(Integer v) throws Exception {
+                return Single.zip(
+                        Single.just(v), getNextOdd,
+                        new BiFunction>() {
+                            @Override
+                            public List apply(Integer a, Integer b) throws Exception {
+                                return Arrays.asList( a, b );
+                            }
+                        }
+                )
+                .toFlowable();
+            }
+        })
+        .takeWhile(new Predicate>() {
+            @Override
+            public boolean test(List v) throws Exception {
+                return v.get(0) < 20;
+            }
+        })
+        .test();
+
+        ts
+        .assertResult(
+                Arrays.asList(0, 1),
+                Arrays.asList(2, 3),
+                Arrays.asList(4, 5),
+                Arrays.asList(6, 7),
+                Arrays.asList(8, 9),
+                Arrays.asList(10, 11),
+                Arrays.asList(12, 13),
+                Arrays.asList(14, 15),
+                Arrays.asList(16, 17),
+                Arrays.asList(18, 19)
+        );
+    }
+
+    @Test
+    public void altConnectCrash() {
+        try {
+            new FlowablePublishAlt(Flowable.empty(), 128)
+            .connect(new Consumer() {
+                @Override
+                public void accept(Disposable t) throws Exception {
+                    throw new TestException();
+                }
+            });
+            fail("Should have thrown");
+        } catch (TestException expected) {
+            // expected
+        }
+    }
+
+    @Test
+    public void altConnectRace() {
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            final ConnectableFlowable cf =
+                    new FlowablePublishAlt(Flowable.never(), 128);
+
+            Runnable r = new Runnable() {
+                @Override
+                public void run() {
+                    cf.connect();
+                }
+            };
+
+            TestHelper.race(r, r);
+        }
+    }
+
+    @Test
+    public void fusedPollCrash() {
+        Flowable.range(1, 5)
+        .map(new Function() {
+            @Override
+            public Object apply(Integer v) throws Exception {
+                throw new TestException();
+            }
+        })
+        .compose(TestHelper.flowableStripBoundary())
+        .publish()
+        .refCount()
+        .test()
+        .assertFailure(TestException.class);
+    }
+
+    @Test
+    public void syncFusedNoRequest() {
+        Flowable.range(1, 5)
+        .publish(1)
+        .refCount()
+        .test()
+        .assertResult(1, 2, 3, 4, 5);
+    }
+
+    @Test
+    public void normalBackpressuredPolls() {
+        Flowable.range(1, 5)
+        .hide()
+        .publish(1)
+        .refCount()
+        .test()
+        .assertResult(1, 2, 3, 4, 5);
+    }
+
+    @Test
+    public void emptyHidden() {
+        Flowable.empty()
+        .hide()
+        .publish(1)
+        .refCount()
+        .test()
+        .assertResult();
+    }
+
+    @Test
+    public void emptyFused() {
+        Flowable.empty()
+        .publish(1)
+        .refCount()
+        .test()
+        .assertResult();
+    }
+
+    @Test
+    public void overflowQueueRefCount() {
+        new Flowable() {
+            @Override
+            protected void subscribeActual(Subscriber s) {
+                s.onSubscribe(new BooleanSubscription());
+                s.onNext(1);
+                s.onNext(2);
+            }
+        }
+        .publish(1)
+        .refCount()
+        .test(0)
+        .requestMore(1)
+        .assertFailure(MissingBackpressureException.class, 1);
+    }
+
+    @Test
+    public void doubleErrorRefCount() {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            new Flowable() {
+                @Override
+                protected void subscribeActual(Subscriber s) {
+                    s.onSubscribe(new BooleanSubscription());
+                    s.onError(new TestException("one"));
+                    s.onError(new TestException("two"));
+                }
+            }
+            .publish(1)
+            .refCount()
+            .test(0)
+            .assertFailureAndMessage(TestException.class, "one");
+
+            TestHelper.assertUndeliverable(errors, 0, TestException.class, "two");
+            assertEquals(1, errors.size());
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+}
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowablePublishTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowablePublishTest.java
index c7c9865f24..80af00c66f 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowablePublishTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowablePublishTest.java
@@ -39,6 +39,28 @@
 
 public class FlowablePublishTest {
 
+    // This will undo the workaround so that the plain ObservablePublish is still
+    // tested.
+    @Before
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public void before() {
+        RxJavaPlugins.setOnConnectableFlowableAssembly(new Function() {
+            @Override
+            public ConnectableFlowable apply(ConnectableFlowable co) throws Exception {
+                if (co instanceof FlowablePublishAlt) {
+                    FlowablePublishAlt fpa = (FlowablePublishAlt) co;
+                    return FlowablePublish.create(Flowable.fromPublisher(fpa.source()), fpa.publishBufferSize());
+                }
+                return co;
+            }
+        });
+    }
+
+    @After
+    public void after() {
+        RxJavaPlugins.setOnConnectableFlowableAssembly(null);
+    }
+
     @Test
     public void testPublish() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
@@ -1368,4 +1390,134 @@ public String apply(Integer t) throws Exception {
     public void badRequest() {
         TestHelper.assertBadRequestReported(Flowable.range(1, 5).publish());
     }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void splitCombineSubscriberChangeAfterOnNext() {
+        Flowable source = Flowable.range(0, 20)
+        .doOnSubscribe(new Consumer() {
+            @Override
+            public void accept(Subscription v) throws Exception {
+                System.out.println("Subscribed");
+            }
+        })
+        .publish(10)
+        .refCount()
+        ;
+
+        Flowable evenNumbers = source.filter(new Predicate() {
+            @Override
+            public boolean test(Integer v) throws Exception {
+                return v % 2 == 0;
+            }
+        });
+
+        Flowable oddNumbers = source.filter(new Predicate() {
+            @Override
+            public boolean test(Integer v) throws Exception {
+                return v % 2 != 0;
+            }
+        });
+
+        final Single getNextOdd = oddNumbers.first(0);
+
+        TestSubscriber> ts = evenNumbers.concatMap(new Function>>() {
+            @Override
+            public Publisher> apply(Integer v) throws Exception {
+                return Single.zip(
+                        Single.just(v), getNextOdd,
+                        new BiFunction>() {
+                            @Override
+                            public List apply(Integer a, Integer b) throws Exception {
+                                return Arrays.asList( a, b );
+                            }
+                        }
+                )
+                .toFlowable();
+            }
+        })
+        .takeWhile(new Predicate>() {
+            @Override
+            public boolean test(List v) throws Exception {
+                return v.get(0) < 20;
+            }
+        })
+        .test();
+
+        ts
+        .assertResult(
+                Arrays.asList(0, 1),
+                Arrays.asList(2, 3),
+                Arrays.asList(4, 5),
+                Arrays.asList(6, 7),
+                Arrays.asList(8, 9),
+                Arrays.asList(10, 11),
+                Arrays.asList(12, 13),
+                Arrays.asList(14, 15),
+                Arrays.asList(16, 17),
+                Arrays.asList(18, 19)
+        );
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void splitCombineSubscriberChangeAfterOnNextFused() {
+        Flowable source = Flowable.range(0, 20)
+        .publish(10)
+        .refCount()
+        ;
+
+        Flowable evenNumbers = source.filter(new Predicate() {
+            @Override
+            public boolean test(Integer v) throws Exception {
+                return v % 2 == 0;
+            }
+        });
+
+        Flowable oddNumbers = source.filter(new Predicate() {
+            @Override
+            public boolean test(Integer v) throws Exception {
+                return v % 2 != 0;
+            }
+        });
+
+        final Single getNextOdd = oddNumbers.first(0);
+
+        TestSubscriber> ts = evenNumbers.concatMap(new Function>>() {
+            @Override
+            public Publisher> apply(Integer v) throws Exception {
+                return Single.zip(
+                        Single.just(v), getNextOdd,
+                        new BiFunction>() {
+                            @Override
+                            public List apply(Integer a, Integer b) throws Exception {
+                                return Arrays.asList( a, b );
+                            }
+                        }
+                )
+                .toFlowable();
+            }
+        })
+        .takeWhile(new Predicate>() {
+            @Override
+            public boolean test(List v) throws Exception {
+                return v.get(0) < 20;
+            }
+        })
+        .test();
+
+        ts
+        .assertResult(
+                Arrays.asList(0, 1),
+                Arrays.asList(2, 3),
+                Arrays.asList(4, 5),
+                Arrays.asList(6, 7),
+                Arrays.asList(8, 9),
+                Arrays.asList(10, 11),
+                Arrays.asList(12, 13),
+                Arrays.asList(14, 15),
+                Arrays.asList(16, 17),
+                Arrays.asList(18, 19)
+        );
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableRangeLongTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableRangeLongTest.java
index 470e0e8cc0..e3d67bb8a2 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableRangeLongTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableRangeLongTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableRangeTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableRangeTest.java
index b0af47585b..3772aefd85 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableRangeTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableRangeTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableReduceTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableReduceTest.java
index 37d7012065..af88de841f 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableReduceTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableReduceTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableRefCountAltTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableRefCountAltTest.java
new file mode 100644
index 0000000000..c8eca05dca
--- /dev/null
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableRefCountAltTest.java
@@ -0,0 +1,1465 @@
+/**
+ * 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.internal.operators.flowable;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import java.io.IOException;
+import java.lang.management.ManagementFactory;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.reactivestreams.*;
+
+import io.reactivex.*;
+import io.reactivex.disposables.*;
+import io.reactivex.exceptions.*;
+import io.reactivex.flowables.ConnectableFlowable;
+import io.reactivex.functions.*;
+import io.reactivex.internal.functions.Functions;
+import io.reactivex.internal.operators.flowable.FlowableRefCount.RefConnection;
+import io.reactivex.internal.subscriptions.BooleanSubscription;
+import io.reactivex.internal.util.ExceptionHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import io.reactivex.processors.*;
+import io.reactivex.schedulers.*;
+import io.reactivex.subscribers.TestSubscriber;
+
+public class FlowableRefCountAltTest {
+
+    @Test
+    public void testRefCountAsync() {
+        final AtomicInteger subscribeCount = new AtomicInteger();
+        final AtomicInteger nextCount = new AtomicInteger();
+        Flowable r = Flowable.interval(0, 20, TimeUnit.MILLISECONDS)
+                .doOnSubscribe(new Consumer() {
+                    @Override
+                    public void accept(Subscription s) {
+                        subscribeCount.incrementAndGet();
+                    }
+                })
+                .doOnNext(new Consumer() {
+                    @Override
+                    public void accept(Long l) {
+                        nextCount.incrementAndGet();
+                    }
+                })
+                .publish().refCount();
+
+        final AtomicInteger receivedCount = new AtomicInteger();
+        Disposable d1 = r.subscribe(new Consumer() {
+            @Override
+            public void accept(Long l) {
+                receivedCount.incrementAndGet();
+            }
+        });
+
+        Disposable d2 = r.subscribe();
+
+        try {
+            Thread.sleep(10);
+        } catch (InterruptedException e) {
+        }
+
+        for (;;) {
+            int a = nextCount.get();
+            int b = receivedCount.get();
+            if (a > 10 && a < 20 && a == b) {
+                break;
+            }
+            if (a >= 20) {
+                break;
+            }
+            try {
+                Thread.sleep(20);
+            } catch (InterruptedException e) {
+            }
+        }
+        // give time to emit
+
+        // now unsubscribe
+        d2.dispose(); // unsubscribe s2 first as we're counting in 1 and there can be a race between unsubscribe and one subscriber getting a value but not the other
+        d1.dispose();
+
+        System.out.println("onNext: " + nextCount.get());
+
+        // should emit once for both subscribers
+        assertEquals(nextCount.get(), receivedCount.get());
+        // only 1 subscribe
+        assertEquals(1, subscribeCount.get());
+    }
+
+    @Test
+    public void testRefCountSynchronous() {
+        final AtomicInteger subscribeCount = new AtomicInteger();
+        final AtomicInteger nextCount = new AtomicInteger();
+        Flowable r = Flowable.just(1, 2, 3, 4, 5, 6, 7, 8, 9)
+                .doOnSubscribe(new Consumer() {
+                    @Override
+                    public void accept(Subscription s) {
+                        subscribeCount.incrementAndGet();
+                    }
+                })
+                .doOnNext(new Consumer() {
+                    @Override
+                    public void accept(Integer l) {
+                        nextCount.incrementAndGet();
+                    }
+                })
+                .publish().refCount();
+
+        final AtomicInteger receivedCount = new AtomicInteger();
+        Disposable d1 = r.subscribe(new Consumer() {
+            @Override
+            public void accept(Integer l) {
+                receivedCount.incrementAndGet();
+            }
+        });
+
+        Disposable d2 = r.subscribe();
+
+        // give time to emit
+        try {
+            Thread.sleep(50);
+        } catch (InterruptedException e) {
+        }
+
+        // now unsubscribe
+        d2.dispose(); // unsubscribe s2 first as we're counting in 1 and there can be a race between unsubscribe and one subscriber getting a value but not the other
+        d1.dispose();
+
+        System.out.println("onNext Count: " + nextCount.get());
+
+        // it will emit twice because it is synchronous
+        assertEquals(nextCount.get(), receivedCount.get() * 2);
+        // it will subscribe twice because it is synchronous
+        assertEquals(2, subscribeCount.get());
+    }
+
+    @Test
+    public void testRefCountSynchronousTake() {
+        final AtomicInteger nextCount = new AtomicInteger();
+        Flowable r = Flowable.just(1, 2, 3, 4, 5, 6, 7, 8, 9)
+                .doOnNext(new Consumer() {
+                    @Override
+                    public void accept(Integer l) {
+                            System.out.println("onNext --------> " + l);
+                            nextCount.incrementAndGet();
+                    }
+                })
+                .take(4)
+                .publish().refCount();
+
+        final AtomicInteger receivedCount = new AtomicInteger();
+        r.subscribe(new Consumer() {
+            @Override
+            public void accept(Integer l) {
+                receivedCount.incrementAndGet();
+            }
+        });
+
+        System.out.println("onNext: " + nextCount.get());
+
+        assertEquals(4, receivedCount.get());
+        assertEquals(4, receivedCount.get());
+    }
+
+    @Test
+    public void testRepeat() {
+        final AtomicInteger subscribeCount = new AtomicInteger();
+        final AtomicInteger unsubscribeCount = new AtomicInteger();
+        Flowable r = Flowable.interval(0, 1, TimeUnit.MILLISECONDS)
+                .doOnSubscribe(new Consumer() {
+                    @Override
+                    public void accept(Subscription s) {
+                            System.out.println("******************************* Subscribe received");
+                            // when we are subscribed
+                            subscribeCount.incrementAndGet();
+                    }
+                })
+                .doOnCancel(new Action() {
+                    @Override
+                    public void run() {
+                            System.out.println("******************************* Unsubscribe received");
+                            // when we are unsubscribed
+                            unsubscribeCount.incrementAndGet();
+                    }
+                })
+                .publish().refCount();
+
+        for (int i = 0; i < 10; i++) {
+            TestSubscriber ts1 = new TestSubscriber();
+            TestSubscriber ts2 = new TestSubscriber();
+            r.subscribe(ts1);
+            r.subscribe(ts2);
+            try {
+                Thread.sleep(50);
+            } catch (InterruptedException e) {
+            }
+            ts1.dispose();
+            ts2.dispose();
+            ts1.assertNoErrors();
+            ts2.assertNoErrors();
+            assertTrue(ts1.valueCount() > 0);
+            assertTrue(ts2.valueCount() > 0);
+        }
+
+        assertEquals(10, subscribeCount.get());
+        assertEquals(10, unsubscribeCount.get());
+    }
+
+    @Test
+    public void testConnectUnsubscribe() throws InterruptedException {
+        final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
+        final CountDownLatch subscribeLatch = new CountDownLatch(1);
+
+        Flowable f = synchronousInterval()
+                .doOnSubscribe(new Consumer() {
+                    @Override
+                    public void accept(Subscription s) {
+                            System.out.println("******************************* Subscribe received");
+                            // when we are subscribed
+                            subscribeLatch.countDown();
+                    }
+                })
+                .doOnCancel(new Action() {
+                    @Override
+                    public void run() {
+                            System.out.println("******************************* Unsubscribe received");
+                            // when we are unsubscribed
+                            unsubscribeLatch.countDown();
+                    }
+                });
+
+        TestSubscriber s = new TestSubscriber();
+        f.publish().refCount().subscribeOn(Schedulers.newThread()).subscribe(s);
+        System.out.println("send unsubscribe");
+        // wait until connected
+        subscribeLatch.await();
+        // now unsubscribe
+        s.dispose();
+        System.out.println("DONE sending unsubscribe ... now waiting");
+        if (!unsubscribeLatch.await(3000, TimeUnit.MILLISECONDS)) {
+            System.out.println("Errors: " + s.errors());
+            if (s.errors().size() > 0) {
+                s.errors().get(0).printStackTrace();
+            }
+            fail("timed out waiting for unsubscribe");
+        }
+        s.assertNoErrors();
+    }
+
+    @Test
+    public void testConnectUnsubscribeRaceConditionLoop() throws InterruptedException {
+        for (int i = 0; i < 100; i++) {
+            testConnectUnsubscribeRaceCondition();
+        }
+    }
+
+    @Test
+    public void testConnectUnsubscribeRaceCondition() throws InterruptedException {
+        final AtomicInteger subUnsubCount = new AtomicInteger();
+        Flowable f = synchronousInterval()
+                .doOnCancel(new Action() {
+                    @Override
+                    public void run() {
+                            System.out.println("******************************* Unsubscribe received");
+                            // when we are unsubscribed
+                            subUnsubCount.decrementAndGet();
+                    }
+                })
+                .doOnSubscribe(new Consumer() {
+                    @Override
+                    public void accept(Subscription s) {
+                            System.out.println("******************************* SUBSCRIBE received");
+                            subUnsubCount.incrementAndGet();
+                    }
+                });
+
+        TestSubscriber s = new TestSubscriber();
+
+        f.publish().refCount().subscribeOn(Schedulers.computation()).subscribe(s);
+        System.out.println("send unsubscribe");
+        // now immediately unsubscribe while subscribeOn is racing to subscribe
+        s.dispose();
+        // this generally will mean it won't even subscribe as it is already unsubscribed by the time connect() gets scheduled
+        // give time to the counter to update
+        Thread.sleep(10);
+        // either we subscribed and then unsubscribed, or we didn't ever even subscribe
+        assertEquals(0, subUnsubCount.get());
+
+        System.out.println("DONE sending unsubscribe ... now waiting");
+        System.out.println("Errors: " + s.errors());
+        if (s.errors().size() > 0) {
+            s.errors().get(0).printStackTrace();
+        }
+        s.assertNoErrors();
+    }
+
+    private Flowable synchronousInterval() {
+        return Flowable.unsafeCreate(new Publisher() {
+            @Override
+            public void subscribe(Subscriber subscriber) {
+                final AtomicBoolean cancel = new AtomicBoolean();
+                subscriber.onSubscribe(new Subscription() {
+                    @Override
+                    public void request(long n) {
+
+                    }
+
+                    @Override
+                    public void cancel() {
+                        cancel.set(true);
+                    }
+
+                });
+                for (;;) {
+                    if (cancel.get()) {
+                        break;
+                    }
+                    try {
+                        Thread.sleep(100);
+                    } catch (InterruptedException e) {
+                    }
+                    subscriber.onNext(1L);
+                }
+            }
+        });
+    }
+
+    @Test
+    public void onlyFirstShouldSubscribeAndLastUnsubscribe() {
+        final AtomicInteger subscriptionCount = new AtomicInteger();
+        final AtomicInteger unsubscriptionCount = new AtomicInteger();
+        Flowable flowable = Flowable.unsafeCreate(new Publisher() {
+            @Override
+            public void subscribe(Subscriber subscriber) {
+                subscriptionCount.incrementAndGet();
+                subscriber.onSubscribe(new Subscription() {
+                    @Override
+                    public void request(long n) {
+
+                    }
+
+                    @Override
+                    public void cancel() {
+                        unsubscriptionCount.incrementAndGet();
+                    }
+                });
+            }
+        });
+        Flowable refCounted = flowable.publish().refCount();
+
+        Disposable first = refCounted.subscribe();
+        assertEquals(1, subscriptionCount.get());
+
+        Disposable second = refCounted.subscribe();
+        assertEquals(1, subscriptionCount.get());
+
+        first.dispose();
+        assertEquals(0, unsubscriptionCount.get());
+
+        second.dispose();
+        assertEquals(1, unsubscriptionCount.get());
+    }
+
+    @Test
+    public void testRefCount() {
+        TestScheduler s = new TestScheduler();
+        Flowable interval = Flowable.interval(100, TimeUnit.MILLISECONDS, s).publish().refCount();
+
+        // subscribe list1
+        final List list1 = new ArrayList();
+        Disposable d1 = interval.subscribe(new Consumer() {
+            @Override
+            public void accept(Long t1) {
+                list1.add(t1);
+            }
+        });
+
+        s.advanceTimeBy(200, TimeUnit.MILLISECONDS);
+
+        assertEquals(2, list1.size());
+        assertEquals(0L, list1.get(0).longValue());
+        assertEquals(1L, list1.get(1).longValue());
+
+        // subscribe list2
+        final List list2 = new ArrayList();
+        Disposable d2 = interval.subscribe(new Consumer() {
+            @Override
+            public void accept(Long t1) {
+                list2.add(t1);
+            }
+        });
+
+        s.advanceTimeBy(300, TimeUnit.MILLISECONDS);
+
+        // list 1 should have 5 items
+        assertEquals(5, list1.size());
+        assertEquals(2L, list1.get(2).longValue());
+        assertEquals(3L, list1.get(3).longValue());
+        assertEquals(4L, list1.get(4).longValue());
+
+        // list 2 should only have 3 items
+        assertEquals(3, list2.size());
+        assertEquals(2L, list2.get(0).longValue());
+        assertEquals(3L, list2.get(1).longValue());
+        assertEquals(4L, list2.get(2).longValue());
+
+        // unsubscribe list1
+        d1.dispose();
+
+        // advance further
+        s.advanceTimeBy(300, TimeUnit.MILLISECONDS);
+
+        // list 1 should still have 5 items
+        assertEquals(5, list1.size());
+
+        // list 2 should have 6 items
+        assertEquals(6, list2.size());
+        assertEquals(5L, list2.get(3).longValue());
+        assertEquals(6L, list2.get(4).longValue());
+        assertEquals(7L, list2.get(5).longValue());
+
+        // unsubscribe list2
+        d2.dispose();
+
+        // advance further
+        s.advanceTimeBy(1000, TimeUnit.MILLISECONDS);
+
+        // subscribing a new one should start over because the source should have been unsubscribed
+        // subscribe list3
+        final List list3 = new ArrayList();
+        interval.subscribe(new Consumer() {
+            @Override
+            public void accept(Long t1) {
+                list3.add(t1);
+            }
+        });
+
+        s.advanceTimeBy(200, TimeUnit.MILLISECONDS);
+
+        assertEquals(2, list3.size());
+        assertEquals(0L, list3.get(0).longValue());
+        assertEquals(1L, list3.get(1).longValue());
+
+    }
+
+    @Test
+    public void testAlreadyUnsubscribedClient() {
+        Subscriber done = CancelledSubscriber.INSTANCE;
+
+        Subscriber subscriber = TestHelper.mockSubscriber();
+
+        Flowable result = Flowable.just(1).publish().refCount();
+
+        result.subscribe(done);
+
+        result.subscribe(subscriber);
+
+        verify(subscriber).onNext(1);
+        verify(subscriber).onComplete();
+        verify(subscriber, never()).onError(any(Throwable.class));
+    }
+
+    @Test
+    public void testAlreadyUnsubscribedInterleavesWithClient() {
+        ReplayProcessor source = ReplayProcessor.create();
+
+        Subscriber done = CancelledSubscriber.INSTANCE;
+
+        Subscriber subscriber = TestHelper.mockSubscriber();
+        InOrder inOrder = inOrder(subscriber);
+
+        Flowable result = source.publish().refCount();
+
+        result.subscribe(subscriber);
+
+        source.onNext(1);
+
+        result.subscribe(done);
+
+        source.onNext(2);
+        source.onComplete();
+
+        inOrder.verify(subscriber).onNext(1);
+        inOrder.verify(subscriber).onNext(2);
+        inOrder.verify(subscriber).onComplete();
+        verify(subscriber, never()).onError(any(Throwable.class));
+    }
+
+    @Test
+    public void testConnectDisconnectConnectAndSubjectState() {
+        Flowable f1 = Flowable.just(10);
+        Flowable f2 = Flowable.just(20);
+        Flowable combined = Flowable.combineLatest(f1, f2, new BiFunction() {
+            @Override
+            public Integer apply(Integer t1, Integer t2) {
+                return t1 + t2;
+            }
+        })
+        .publish().refCount();
+
+        TestSubscriber ts1 = new TestSubscriber();
+        TestSubscriber ts2 = new TestSubscriber();
+
+        combined.subscribe(ts1);
+        combined.subscribe(ts2);
+
+        ts1.assertTerminated();
+        ts1.assertNoErrors();
+        ts1.assertValue(30);
+
+        ts2.assertTerminated();
+        ts2.assertNoErrors();
+        ts2.assertValue(30);
+    }
+
+    @Test(timeout = 10000)
+    public void testUpstreamErrorAllowsRetry() throws InterruptedException {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            final AtomicInteger intervalSubscribed = new AtomicInteger();
+            Flowable interval =
+                    Flowable.interval(200, TimeUnit.MILLISECONDS)
+                            .doOnSubscribe(new Consumer() {
+                                @Override
+                                public void accept(Subscription s) {
+                                                System.out.println("Subscribing to interval " + intervalSubscribed.incrementAndGet());
+                                        }
+                            }
+                             )
+                            .flatMap(new Function>() {
+                                @Override
+                                public Publisher apply(Long t1) {
+                                        return Flowable.defer(new Callable>() {
+                                            @Override
+                                            public Publisher call() {
+                                                    return Flowable.error(new TestException("Some exception"));
+                                            }
+                                        });
+                                }
+                            })
+                            .onErrorResumeNext(new Function>() {
+                                @Override
+                                public Publisher apply(Throwable t1) {
+                                        return Flowable.error(t1);
+                                }
+                            })
+                            .publish()
+                            .refCount();
+
+            interval
+                    .doOnError(new Consumer() {
+                        @Override
+                        public void accept(Throwable t1) {
+                                System.out.println("Subscriber 1 onError: " + t1);
+                        }
+                    })
+                    .retry(5)
+                    .subscribe(new Consumer() {
+                        @Override
+                        public void accept(String t1) {
+                                System.out.println("Subscriber 1: " + t1);
+                        }
+                    });
+            Thread.sleep(100);
+            interval
+            .doOnError(new Consumer() {
+                @Override
+                public void accept(Throwable t1) {
+                        System.out.println("Subscriber 2 onError: " + t1);
+                }
+            })
+            .retry(5)
+                    .subscribe(new Consumer() {
+                        @Override
+                        public void accept(String t1) {
+                                System.out.println("Subscriber 2: " + t1);
+                        }
+                    });
+
+            Thread.sleep(1300);
+
+            System.out.println(intervalSubscribed.get());
+            assertEquals(6, intervalSubscribed.get());
+
+            TestHelper.assertError(errors, 0, OnErrorNotImplementedException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    private enum CancelledSubscriber implements FlowableSubscriber {
+        INSTANCE;
+
+        @Override public void onSubscribe(Subscription s) {
+            s.cancel();
+        }
+
+        @Override public void onNext(Integer o) {
+        }
+
+        @Override public void onError(Throwable t) {
+        }
+
+        @Override public void onComplete() {
+        }
+    }
+
+    @Test
+    public void disposed() {
+        TestHelper.checkDisposed(Flowable.just(1).publish().refCount());
+    }
+
+    @Test
+    public void noOpConnect() {
+        final int[] calls = { 0 };
+        Flowable f = new ConnectableFlowable() {
+            @Override
+            public void connect(Consumer connection) {
+                calls[0]++;
+            }
+
+            @Override
+            protected void subscribeActual(Subscriber subscriber) {
+                subscriber.onSubscribe(new BooleanSubscription());
+            }
+        }.refCount();
+
+        f.test();
+        f.test();
+
+        assertEquals(1, calls[0]);
+    }
+
+    Flowable source;
+
+    @Test
+    public void replayNoLeak() throws Exception {
+        Thread.sleep(100);
+        System.gc();
+        Thread.sleep(100);
+
+        long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = Flowable.fromCallable(new Callable() {
+            @Override
+            public Object call() throws Exception {
+                return new byte[100 * 1000 * 1000];
+            }
+        })
+        .replay(1)
+        .refCount();
+
+        source.subscribe();
+
+        Thread.sleep(100);
+        System.gc();
+        Thread.sleep(100);
+
+        long after = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = null;
+        assertTrue(String.format("%,3d -> %,3d%n", start, after), start + 20 * 1000 * 1000 > after);
+    }
+
+    @Test
+    public void replayNoLeak2() throws Exception {
+        Thread.sleep(100);
+        System.gc();
+        Thread.sleep(100);
+
+        long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = Flowable.fromCallable(new Callable() {
+            @Override
+            public Object call() throws Exception {
+                return new byte[100 * 1000 * 1000];
+            }
+        }).concatWith(Flowable.never())
+        .replay(1)
+        .refCount();
+
+        Disposable d1 = source.subscribe();
+        Disposable d2 = source.subscribe();
+
+        d1.dispose();
+        d2.dispose();
+
+        d1 = null;
+        d2 = null;
+
+        Thread.sleep(100);
+        System.gc();
+        Thread.sleep(100);
+
+        long after = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = null;
+        assertTrue(String.format("%,3d -> %,3d%n", start, after), start + 20 * 1000 * 1000 > after);
+    }
+
+    static final class ExceptionData extends Exception {
+        private static final long serialVersionUID = -6763898015338136119L;
+
+        public final Object data;
+
+        ExceptionData(Object data) {
+            this.data = data;
+        }
+    }
+
+    @Test
+    public void publishNoLeak() throws Exception {
+        Thread.sleep(100);
+        System.gc();
+        Thread.sleep(100);
+
+        long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = Flowable.fromCallable(new Callable() {
+            @Override
+            public Object call() throws Exception {
+                throw new ExceptionData(new byte[100 * 1000 * 1000]);
+            }
+        })
+        .publish()
+        .refCount();
+
+        source.subscribe(Functions.emptyConsumer(), Functions.emptyConsumer());
+
+        Thread.sleep(100);
+        System.gc();
+        Thread.sleep(200);
+
+        long after = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = null;
+
+        assertTrue(String.format("%,3d -> %,3d%n", start, after), start + 20 * 1000 * 1000 > after);
+    }
+
+    @Test
+    public void publishNoLeak2() throws Exception {
+        System.gc();
+        Thread.sleep(100);
+
+        long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = Flowable.fromCallable(new Callable() {
+            @Override
+            public Object call() throws Exception {
+                return new byte[100 * 1000 * 1000];
+            }
+        }).concatWith(Flowable.never())
+        .publish()
+        .refCount();
+
+        Disposable d1 = source.test();
+        Disposable d2 = source.test();
+
+        d1.dispose();
+        d2.dispose();
+
+        d1 = null;
+        d2 = null;
+
+        System.gc();
+        Thread.sleep(100);
+
+        long after = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = null;
+        assertTrue(String.format("%,3d -> %,3d%n", start, after), start + 20 * 1000 * 1000 > after);
+    }
+
+    @Test
+    public void replayIsUnsubscribed() {
+        ConnectableFlowable cf = Flowable.just(1)
+        .replay();
+
+        if (cf instanceof Disposable) {
+            assertTrue(((Disposable)cf).isDisposed());
+
+            Disposable connection = cf.connect();
+
+            assertFalse(((Disposable)cf).isDisposed());
+
+            connection.dispose();
+
+            assertTrue(((Disposable)cf).isDisposed());
+        }
+    }
+
+    static final class BadFlowableSubscribe extends ConnectableFlowable {
+
+        @Override
+        public void connect(Consumer connection) {
+            try {
+                connection.accept(Disposables.empty());
+            } catch (Throwable ex) {
+                throw ExceptionHelper.wrapOrThrow(ex);
+            }
+        }
+
+        @Override
+        protected void subscribeActual(Subscriber subscriber) {
+            throw new TestException("subscribeActual");
+        }
+    }
+
+    static final class BadFlowableDispose extends ConnectableFlowable implements Disposable {
+
+        @Override
+        public void dispose() {
+            throw new TestException("dispose");
+        }
+
+        @Override
+        public boolean isDisposed() {
+            return false;
+        }
+
+        @Override
+        public void connect(Consumer connection) {
+            try {
+                connection.accept(Disposables.empty());
+            } catch (Throwable ex) {
+                throw ExceptionHelper.wrapOrThrow(ex);
+            }
+        }
+
+        @Override
+        protected void subscribeActual(Subscriber subscriber) {
+            subscriber.onSubscribe(new BooleanSubscription());
+        }
+    }
+
+    static final class BadFlowableConnect extends ConnectableFlowable {
+
+        @Override
+        public void connect(Consumer connection) {
+            throw new TestException("connect");
+        }
+
+        @Override
+        protected void subscribeActual(Subscriber subscriber) {
+            subscriber.onSubscribe(new BooleanSubscription());
+        }
+    }
+
+    @Test
+    public void badSourceSubscribe() {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            BadFlowableSubscribe bo = new BadFlowableSubscribe();
+
+            try {
+                bo.refCount()
+                .test();
+                fail("Should have thrown");
+            } catch (NullPointerException ex) {
+                assertTrue(ex.getCause() instanceof TestException);
+            }
+
+            TestHelper.assertUndeliverable(errors, 0, TestException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    @Test
+    public void badSourceDispose() {
+        BadFlowableDispose bf = new BadFlowableDispose();
+
+        try {
+            bf.refCount()
+            .test()
+            .cancel();
+            fail("Should have thrown");
+        } catch (TestException expected) {
+        }
+    }
+
+    @Test
+    public void badSourceConnect() {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            BadFlowableConnect bf = new BadFlowableConnect();
+
+            try {
+                bf.refCount()
+                .test();
+                fail("Should have thrown");
+            } catch (NullPointerException ex) {
+                assertTrue(ex.getCause() instanceof TestException);
+            }
+
+            TestHelper.assertUndeliverable(errors, 0, TestException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    static final class BadFlowableSubscribe2 extends ConnectableFlowable {
+
+        int count;
+
+        @Override
+        public void connect(Consumer connection) {
+            try {
+                connection.accept(Disposables.empty());
+            } catch (Throwable ex) {
+                throw ExceptionHelper.wrapOrThrow(ex);
+            }
+        }
+
+        @Override
+        protected void subscribeActual(Subscriber subscriber) {
+            if (++count == 1) {
+                subscriber.onSubscribe(new BooleanSubscription());
+            } else {
+                throw new TestException("subscribeActual");
+            }
+        }
+    }
+
+    @Test
+    public void badSourceSubscribe2() {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            BadFlowableSubscribe2 bf = new BadFlowableSubscribe2();
+
+            Flowable f = bf.refCount();
+            f.test();
+            try {
+                f.test();
+                fail("Should have thrown");
+            } catch (NullPointerException ex) {
+                assertTrue(ex.getCause() instanceof TestException);
+            }
+
+            TestHelper.assertUndeliverable(errors, 0, TestException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    static final class BadFlowableConnect2 extends ConnectableFlowable
+    implements Disposable {
+
+        @Override
+        public void connect(Consumer connection) {
+            try {
+                connection.accept(Disposables.empty());
+            } catch (Throwable ex) {
+                throw ExceptionHelper.wrapOrThrow(ex);
+            }
+        }
+
+        @Override
+        protected void subscribeActual(Subscriber subscriber) {
+            subscriber.onSubscribe(new BooleanSubscription());
+            subscriber.onComplete();
+        }
+
+        @Override
+        public void dispose() {
+            throw new TestException("dispose");
+        }
+
+        @Override
+        public boolean isDisposed() {
+            return false;
+        }
+    }
+
+    @Test
+    public void badSourceCompleteDisconnect() {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            BadFlowableConnect2 bf = new BadFlowableConnect2();
+
+            try {
+                bf.refCount()
+                .test();
+                fail("Should have thrown");
+            } catch (NullPointerException ex) {
+                assertTrue(ex.getCause() instanceof TestException);
+            }
+
+            TestHelper.assertUndeliverable(errors, 0, TestException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    @Test(timeout = 7500)
+    public void blockingSourceAsnycCancel() throws Exception {
+        BehaviorProcessor bp = BehaviorProcessor.createDefault(1);
+
+        Flowable f = bp
+        .replay(1)
+        .refCount();
+
+        f.subscribe();
+
+        final AtomicBoolean interrupted = new AtomicBoolean();
+
+        f.switchMap(new Function>() {
+            @Override
+            public Publisher apply(Integer v) throws Exception {
+                return Flowable.create(new FlowableOnSubscribe() {
+                    @Override
+                    public void subscribe(FlowableEmitter emitter) throws Exception {
+                        while (!emitter.isCancelled()) {
+                            Thread.sleep(100);
+                        }
+                        interrupted.set(true);
+                    }
+                }, BackpressureStrategy.MISSING);
+            }
+        })
+        .takeUntil(Flowable.timer(500, TimeUnit.MILLISECONDS))
+        .test()
+        .awaitDone(5, TimeUnit.SECONDS)
+        .assertResult();
+
+        assertTrue(interrupted.get());
+    }
+
+    @Test
+    public void byCount() {
+        final int[] subscriptions = { 0 };
+
+        Flowable source = Flowable.range(1, 5)
+        .doOnSubscribe(new Consumer() {
+            @Override
+            public void accept(Subscription s) throws Exception {
+                subscriptions[0]++;
+            }
+        })
+        .publish()
+        .refCount(2);
+
+        for (int i = 0; i < 3; i++) {
+            TestSubscriber ts1 = source.test();
+
+            ts1.assertEmpty();
+
+            TestSubscriber ts2 = source.test();
+
+            ts1.assertResult(1, 2, 3, 4, 5);
+            ts2.assertResult(1, 2, 3, 4, 5);
+        }
+
+        assertEquals(3, subscriptions[0]);
+    }
+
+    @Test
+    public void resubscribeBeforeTimeout() throws Exception {
+        final int[] subscriptions = { 0 };
+
+        PublishProcessor pp = PublishProcessor.create();
+
+        Flowable source = pp
+        .doOnSubscribe(new Consumer() {
+            @Override
+            public void accept(Subscription s) throws Exception {
+                subscriptions[0]++;
+            }
+        })
+        .publish()
+        .refCount(500, TimeUnit.MILLISECONDS);
+
+        TestSubscriber ts1 = source.test(0);
+
+        assertEquals(1, subscriptions[0]);
+
+        ts1.cancel();
+
+        Thread.sleep(100);
+
+        ts1 = source.test(0);
+
+        assertEquals(1, subscriptions[0]);
+
+        Thread.sleep(500);
+
+        assertEquals(1, subscriptions[0]);
+
+        pp.onNext(1);
+        pp.onNext(2);
+        pp.onNext(3);
+        pp.onNext(4);
+        pp.onNext(5);
+        pp.onComplete();
+
+        ts1.requestMore(5)
+        .assertResult(1, 2, 3, 4, 5);
+    }
+
+    @Test
+    public void letitTimeout() throws Exception {
+        final int[] subscriptions = { 0 };
+
+        PublishProcessor pp = PublishProcessor.create();
+
+        Flowable source = pp
+        .doOnSubscribe(new Consumer() {
+            @Override
+            public void accept(Subscription s) throws Exception {
+                subscriptions[0]++;
+            }
+        })
+        .publish()
+        .refCount(1, 100, TimeUnit.MILLISECONDS);
+
+        TestSubscriber ts1 = source.test(0);
+
+        assertEquals(1, subscriptions[0]);
+
+        ts1.cancel();
+
+        assertTrue(pp.hasSubscribers());
+
+        Thread.sleep(200);
+
+        assertFalse(pp.hasSubscribers());
+    }
+
+    @Test
+    public void error() {
+        Flowable.error(new IOException())
+        .publish()
+        .refCount(500, TimeUnit.MILLISECONDS)
+        .test()
+        .assertFailure(IOException.class);
+    }
+
+    @Test
+    public void comeAndGo() {
+        PublishProcessor pp = PublishProcessor.create();
+
+        Flowable source = pp
+        .publish()
+        .refCount(1);
+
+        TestSubscriber ts1 = source.test(0);
+
+        assertTrue(pp.hasSubscribers());
+
+        for (int i = 0; i < 3; i++) {
+            TestSubscriber ts2 = source.test();
+            ts1.cancel();
+            ts1 = ts2;
+        }
+
+        ts1.cancel();
+
+        assertFalse(pp.hasSubscribers());
+    }
+
+    @Test
+    public void unsubscribeSubscribeRace() {
+        for (int i = 0; i < 1000; i++) {
+
+            final Flowable source = Flowable.range(1, 5)
+                    .replay()
+                    .refCount(1)
+                    ;
+
+            final TestSubscriber ts1 = source.test(0);
+
+            final TestSubscriber ts2 = new TestSubscriber(0);
+
+            Runnable r1 = new Runnable() {
+                @Override
+                public void run() {
+                    ts1.cancel();
+                }
+            };
+
+            Runnable r2 = new Runnable() {
+                @Override
+                public void run() {
+                    source.subscribe(ts2);
+                }
+            };
+
+            TestHelper.race(r1, r2, Schedulers.single());
+
+            ts2.requestMore(6) // FIXME RxJava replay() doesn't issue onComplete without request
+            .withTag("Round: " + i)
+            .assertResult(1, 2, 3, 4, 5);
+        }
+    }
+
+    static final class BadFlowableDoubleOnX extends ConnectableFlowable
+    implements Disposable {
+
+        @Override
+        public void connect(Consumer connection) {
+            try {
+                connection.accept(Disposables.empty());
+            } catch (Throwable ex) {
+                throw ExceptionHelper.wrapOrThrow(ex);
+            }
+        }
+
+        @Override
+        protected void subscribeActual(Subscriber subscriber) {
+            subscriber.onSubscribe(new BooleanSubscription());
+            subscriber.onSubscribe(new BooleanSubscription());
+            subscriber.onComplete();
+            subscriber.onComplete();
+            subscriber.onError(new TestException());
+        }
+
+        @Override
+        public void dispose() {
+        }
+
+        @Override
+        public boolean isDisposed() {
+            return false;
+        }
+    }
+
+    @Test
+    public void doubleOnX() {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            new BadFlowableDoubleOnX()
+            .refCount()
+            .test()
+            .assertResult();
+
+            TestHelper.assertError(errors, 0, ProtocolViolationException.class);
+            TestHelper.assertUndeliverable(errors, 1, TestException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    @Test
+    public void doubleOnXCount() {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            new BadFlowableDoubleOnX()
+            .refCount(1)
+            .test()
+            .assertResult();
+
+            TestHelper.assertError(errors, 0, ProtocolViolationException.class);
+            TestHelper.assertUndeliverable(errors, 1, TestException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    @Test
+    public void doubleOnXTime() {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            new BadFlowableDoubleOnX()
+            .refCount(5, TimeUnit.SECONDS, Schedulers.single())
+            .test()
+            .assertResult();
+
+            TestHelper.assertError(errors, 0, ProtocolViolationException.class);
+            TestHelper.assertUndeliverable(errors, 1, TestException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    @Test
+    public void cancelTerminateStateExclusion() {
+        FlowableRefCount o = (FlowableRefCount)PublishProcessor.create()
+        .publish()
+        .refCount();
+
+        o.cancel(null);
+
+        RefConnection rc = new RefConnection(o);
+        o.connection = null;
+        rc.subscriberCount = 0;
+        o.timeout(rc);
+
+        rc.subscriberCount = 1;
+        o.timeout(rc);
+
+        o.connection = rc;
+        o.timeout(rc);
+
+        rc.subscriberCount = 0;
+        o.timeout(rc);
+
+        // -------------------
+
+        rc.subscriberCount = 2;
+        rc.connected = false;
+        o.connection = rc;
+        o.cancel(rc);
+
+        rc.subscriberCount = 1;
+        rc.connected = false;
+        o.connection = rc;
+        o.cancel(rc);
+
+        rc.subscriberCount = 2;
+        rc.connected = true;
+        o.connection = rc;
+        o.cancel(rc);
+
+        rc.subscriberCount = 1;
+        rc.connected = true;
+        o.connection = rc;
+        rc.set(null);
+        o.cancel(rc);
+
+        o.connection = rc;
+        o.cancel(new RefConnection(o));
+    }
+
+    @Test
+    public void replayRefCountShallBeThreadSafe() {
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            Flowable flowable = Flowable.just(1).replay(1).refCount();
+
+            TestSubscriber ts1 = flowable
+                    .subscribeOn(Schedulers.io())
+                    .test();
+
+            TestSubscriber ts2 = flowable
+                    .subscribeOn(Schedulers.io())
+                    .test();
+
+            ts1
+            .withTag("" + i)
+            .awaitDone(5, TimeUnit.SECONDS)
+            .assertResult(1);
+
+            ts2
+            .withTag("" + i)
+            .awaitDone(5, TimeUnit.SECONDS)
+            .assertResult(1);
+        }
+    }
+
+    static final class TestConnectableFlowable extends ConnectableFlowable
+    implements Disposable {
+
+        volatile boolean disposed;
+
+        @Override
+        public void dispose() {
+            disposed = true;
+        }
+
+        @Override
+        public boolean isDisposed() {
+            return disposed;
+        }
+
+        @Override
+        public void connect(Consumer connection) {
+            // not relevant
+        }
+
+        @Override
+        protected void subscribeActual(Subscriber subscriber) {
+            // not relevant
+        }
+    }
+
+    @Test
+    public void timeoutDisposesSource() {
+        FlowableRefCount o = (FlowableRefCount)new TestConnectableFlowable().refCount();
+
+        RefConnection rc = new RefConnection(o);
+        o.connection = rc;
+
+        o.timeout(rc);
+
+        assertTrue(((Disposable)o.source).isDisposed());
+    }
+
+    @Test
+    public void disconnectBeforeConnect() {
+        BehaviorProcessor processor = BehaviorProcessor.create();
+
+        Flowable flowable = processor
+                .replay(1)
+                .refCount();
+
+        flowable.takeUntil(Flowable.just(1)).test();
+
+        processor.onNext(2);
+
+        flowable.take(1).test().assertResult(2);
+    }
+
+    @Test
+    public void publishRefCountShallBeThreadSafe() {
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            Flowable flowable = Flowable.just(1).publish().refCount();
+
+            TestSubscriber subscriber1 = flowable
+                    .subscribeOn(Schedulers.io())
+                    .test();
+
+            TestSubscriber subscriber2 = flowable
+                    .subscribeOn(Schedulers.io())
+                    .test();
+
+            subscriber1
+            .withTag("subscriber1 " + i)
+            .awaitDone(5, TimeUnit.SECONDS)
+            .assertNoErrors()
+            .assertComplete();
+
+            subscriber2
+            .withTag("subscriber2 " + i)
+            .awaitDone(5, TimeUnit.SECONDS)
+            .assertNoErrors()
+            .assertComplete();
+        }
+    }
+
+    @Test
+    public void upstreamTerminationTriggersAnotherCancel() throws Exception {
+        ReplayProcessor rp = ReplayProcessor.create();
+        rp.onNext(1);
+        rp.onComplete();
+
+        Flowable shared = rp.share();
+
+        shared
+        .buffer(shared.debounce(5, TimeUnit.SECONDS))
+        .test()
+        .assertValueCount(2);
+
+        shared
+        .buffer(shared.debounce(5, TimeUnit.SECONDS))
+        .test()
+        .assertValueCount(2);
+    }
+}
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableRefCountTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableRefCountTest.java
index 673a0f4add..c032e61da5 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableRefCountTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableRefCountTest.java
@@ -23,7 +23,7 @@
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 
-import org.junit.Test;
+import org.junit.*;
 import org.mockito.InOrder;
 import org.reactivestreams.*;
 
@@ -43,6 +43,28 @@
 
 public class FlowableRefCountTest {
 
+    // This will undo the workaround so that the plain ObservablePublish is still
+    // tested.
+    @Before
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public void before() {
+        RxJavaPlugins.setOnConnectableFlowableAssembly(new Function() {
+            @Override
+            public ConnectableFlowable apply(ConnectableFlowable co) throws Exception {
+                if (co instanceof FlowablePublishAlt) {
+                    FlowablePublishAlt fpa = (FlowablePublishAlt) co;
+                    return FlowablePublish.create(Flowable.fromPublisher(fpa.source()), fpa.publishBufferSize());
+                }
+                return co;
+            }
+        });
+    }
+
+    @After
+    public void after() {
+        RxJavaPlugins.setOnConnectableFlowableAssembly(null);
+    }
+
     @Test
     public void testRefCountAsync() {
         final AtomicInteger subscribeCount = new AtomicInteger();
@@ -653,6 +675,7 @@ protected void subscribeActual(Subscriber subscriber) {
 
     @Test
     public void replayNoLeak() throws Exception {
+        Thread.sleep(100);
         System.gc();
         Thread.sleep(100);
 
@@ -669,6 +692,7 @@ public Object call() throws Exception {
 
         source.subscribe();
 
+        Thread.sleep(100);
         System.gc();
         Thread.sleep(100);
 
@@ -680,6 +704,7 @@ public Object call() throws Exception {
 
     @Test
     public void replayNoLeak2() throws Exception {
+        Thread.sleep(100);
         System.gc();
         Thread.sleep(100);
 
@@ -703,6 +728,7 @@ public Object call() throws Exception {
         d1 = null;
         d2 = null;
 
+        Thread.sleep(100);
         System.gc();
         Thread.sleep(100);
 
@@ -724,6 +750,7 @@ static final class ExceptionData extends Exception {
 
     @Test
     public void publishNoLeak() throws Exception {
+        Thread.sleep(100);
         System.gc();
         Thread.sleep(100);
 
@@ -740,6 +767,7 @@ public Object call() throws Exception {
 
         source.subscribe(Functions.emptyConsumer(), Functions.emptyConsumer());
 
+        Thread.sleep(100);
         System.gc();
         Thread.sleep(100);
 
@@ -1409,4 +1437,23 @@ public void disconnectBeforeConnect() {
 
         flowable.take(1).test().assertResult(2);
     }
+
+    @Test
+    public void upstreamTerminationTriggersAnotherCancel() throws Exception {
+        ReplayProcessor rp = ReplayProcessor.create();
+        rp.onNext(1);
+        rp.onComplete();
+
+        Flowable shared = rp.share();
+
+        shared
+        .buffer(shared.debounce(5, TimeUnit.SECONDS))
+        .test()
+        .assertValueCount(2);
+
+        shared
+        .buffer(shared.debounce(5, TimeUnit.SECONDS))
+        .test()
+        .assertValueCount(2);
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableRepeatTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableRepeatTest.java
index 51376bc594..46d240b620 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableRepeatTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableRepeatTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
@@ -29,6 +28,7 @@
 import io.reactivex.exceptions.TestException;
 import io.reactivex.functions.*;
 import io.reactivex.internal.subscriptions.BooleanSubscription;
+import io.reactivex.plugins.RxJavaPlugins;
 import io.reactivex.processors.PublishProcessor;
 import io.reactivex.schedulers.Schedulers;
 import io.reactivex.subscribers.TestSubscriber;
@@ -441,4 +441,56 @@ public boolean test(Object v) throws Exception {
 
         assertEquals(0, counter.get());
     }
+
+    @Test
+    public void repeatFloodNoSubscriptionError() {
+        List errors = TestHelper.trackPluginErrors();
+
+        try {
+            final PublishProcessor source = PublishProcessor.create();
+            final PublishProcessor signaller = PublishProcessor.create();
+
+            for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+
+                TestSubscriber ts = source.take(1)
+                .repeatWhen(new Function, Flowable>() {
+                    @Override
+                    public Flowable apply(Flowable v)
+                            throws Exception {
+                        return signaller;
+                    }
+                }).test();
+
+                Runnable r1 = new Runnable() {
+                    @Override
+                    public void run() {
+                        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+                            source.onNext(1);
+                        }
+                    }
+                };
+                Runnable r2 = new Runnable() {
+                    @Override
+                    public void run() {
+                        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+                            signaller.offer(1);
+                        }
+                    }
+                };
+
+                TestHelper.race(r1, r2);
+
+                ts.dispose();
+            }
+
+            if (!errors.isEmpty()) {
+                for (Throwable e : errors) {
+                    e.printStackTrace();
+                }
+                fail(errors + "");
+            }
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableReplayTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableReplayTest.java
index dcf7eea347..56daf0c5e5 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableReplayTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableReplayTest.java
@@ -14,9 +14,9 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
+import java.lang.management.*;
 import java.util.*;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
@@ -1976,4 +1976,67 @@ public void currentDisposedWhenConnecting() {
 
         assertFalse(fr.current.get().isDisposed());
     }
+
+    @Test
+    public void noBoundedRetentionViaThreadLocal() throws Exception {
+        Flowable source = Flowable.range(1, 200)
+        .map(new Function() {
+            @Override
+            public byte[] apply(Integer v) throws Exception {
+                return new byte[1024 * 1024];
+            }
+        })
+        .replay(new Function, Publisher>() {
+            @Override
+            public Publisher apply(final Flowable f) throws Exception {
+                return f.take(1)
+                .concatMap(new Function>() {
+                    @Override
+                    public Publisher apply(byte[] v) throws Exception {
+                        return f;
+                    }
+                });
+            }
+        }, 1)
+        .takeLast(1)
+        ;
+
+        System.out.println("Bounded Replay Leak check: Wait before GC");
+        Thread.sleep(1000);
+
+        System.out.println("Bounded Replay Leak check: GC");
+        System.gc();
+
+        Thread.sleep(500);
+
+        final MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
+        MemoryUsage memHeap = memoryMXBean.getHeapMemoryUsage();
+        long initial = memHeap.getUsed();
+
+        System.out.printf("Bounded Replay Leak check: Starting: %.3f MB%n", initial / 1024.0 / 1024.0);
+
+        final AtomicLong after = new AtomicLong();
+
+        source.subscribe(new Consumer() {
+            @Override
+            public void accept(byte[] v) throws Exception {
+                System.out.println("Bounded Replay Leak check: Wait before GC 2");
+                Thread.sleep(1000);
+
+                System.out.println("Bounded Replay Leak check:  GC 2");
+                System.gc();
+
+                Thread.sleep(500);
+
+                after.set(memoryMXBean.getHeapMemoryUsage().getUsed());
+            }
+        });
+
+        System.out.printf("Bounded Replay Leak check: After: %.3f MB%n", after.get() / 1024.0 / 1024.0);
+
+        if (initial + 100 * 1024 * 1024 < after.get()) {
+            Assert.fail("Bounded Replay Leak check: Memory leak detected: " + (initial / 1024.0 / 1024.0)
+                    + " -> " + after.get() / 1024.0 / 1024.0);
+        }
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableRetryTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableRetryTest.java
index a5dd4918ab..d0c73867e6 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableRetryTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableRetryTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
@@ -32,6 +31,7 @@
 import io.reactivex.functions.*;
 import io.reactivex.internal.functions.Functions;
 import io.reactivex.internal.subscriptions.BooleanSubscription;
+import io.reactivex.plugins.RxJavaPlugins;
 import io.reactivex.processors.PublishProcessor;
 import io.reactivex.schedulers.Schedulers;
 import io.reactivex.subscribers.*;
@@ -1221,4 +1221,64 @@ public boolean test(Object v) throws Exception {
 
         assertEquals(0, counter.get());
     }
+
+    @Test
+    public void repeatFloodNoSubscriptionError() {
+        List errors = TestHelper.trackPluginErrors();
+
+        final TestException error = new TestException();
+
+        try {
+            final PublishProcessor source = PublishProcessor.create();
+            final PublishProcessor signaller = PublishProcessor.create();
+
+            for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+
+                TestSubscriber ts = source.take(1)
+                .map(new Function() {
+                    @Override
+                    public Integer apply(Integer v) throws Exception {
+                        throw error;
+                    }
+                })
+                .retryWhen(new Function, Flowable>() {
+                    @Override
+                    public Flowable apply(Flowable v)
+                            throws Exception {
+                        return signaller;
+                    }
+                }).test();
+
+                Runnable r1 = new Runnable() {
+                    @Override
+                    public void run() {
+                        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+                            source.onNext(1);
+                        }
+                    }
+                };
+                Runnable r2 = new Runnable() {
+                    @Override
+                    public void run() {
+                        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+                            signaller.offer(1);
+                        }
+                    }
+                };
+
+                TestHelper.race(r1, r2);
+
+                ts.dispose();
+            }
+
+            if (!errors.isEmpty()) {
+                for (Throwable e : errors) {
+                    e.printStackTrace();
+                }
+                fail(errors + "");
+            }
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableRetryWithPredicateTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableRetryWithPredicateTest.java
index de31e283a4..c24e4f5f7d 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableRetryWithPredicateTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableRetryWithPredicateTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableSampleTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableSampleTest.java
index 74cbcc24c2..1ea39f76ce 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableSampleTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableSampleTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.assertFalse;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.concurrent.TimeUnit;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableScanTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableScanTest.java
index 7e761ca53f..1b2b9ac4ca 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableScanTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableScanTest.java
@@ -24,7 +24,6 @@
 import org.reactivestreams.*;
 
 import io.reactivex.*;
-import io.reactivex.Flowable;
 import io.reactivex.exceptions.*;
 import io.reactivex.flowable.*;
 import io.reactivex.flowable.FlowableEventStream.Event;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableSequenceEqualTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableSequenceEqualTest.java
index fb65114e42..b40a40bb56 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableSequenceEqualTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableSequenceEqualTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.flowable;
 
-import static org.mockito.ArgumentMatchers.isA;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableSingleTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableSingleTest.java
index 62f662804f..71085466cb 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableSingleTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableSingleTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableSkipLastTimedTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableSkipLastTimedTest.java
index d24a84b4b6..31c8294a64 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableSkipLastTimedTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableSkipLastTimedTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.flowable;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.concurrent.TimeUnit;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableSkipWhileTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableSkipWhileTest.java
index b9574cd8ef..0ac4a1369e 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableSkipWhileTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableSkipWhileTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.flowable;
 
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import org.junit.Test;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableSwitchTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableSwitchTest.java
index dc5f2a8313..794e43e273 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableSwitchTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableSwitchTest.java
@@ -19,7 +19,7 @@
 
 import java.util.*;
 import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.*;
 
 import org.junit.*;
 import org.mockito.InOrder;
@@ -1202,4 +1202,102 @@ public Object apply(Integer w) throws Exception {
         .assertNoErrors()
         .assertComplete();
     }
+
+    @Test
+    public void switchMapFusedIterable() {
+        Flowable.range(1, 2)
+        .switchMap(new Function>() {
+            @Override
+            public Publisher apply(Integer v)
+                    throws Exception {
+                return Flowable.fromIterable(Arrays.asList(v * 10));
+            }
+        })
+        .test()
+        .assertResult(10, 20);
+    }
+
+    @Test
+    public void switchMapHiddenIterable() {
+        Flowable.range(1, 2)
+        .switchMap(new Function>() {
+            @Override
+            public Publisher apply(Integer v)
+                    throws Exception {
+                return Flowable.fromIterable(Arrays.asList(v * 10)).hide();
+            }
+        })
+        .test()
+        .assertResult(10, 20);
+    }
+
+    @Test
+    public void cancellationShouldTriggerInnerCancellationRace() throws Throwable {
+        final AtomicInteger outer = new AtomicInteger();
+        final AtomicInteger inner = new AtomicInteger();
+
+        int n = 10000;
+        for (int i = 0; i < n; i++) {
+            Flowable.create(new FlowableOnSubscribe() {
+                @Override
+                public void subscribe(FlowableEmitter it)
+                        throws Exception {
+                            it.onNext(0);
+                        }
+            }, BackpressureStrategy.MISSING)
+            .switchMap(new Function>() {
+                @Override
+                public Publisher apply(Integer v)
+                        throws Exception {
+                    return createFlowable(inner);
+                }
+            })
+            .observeOn(Schedulers.computation())
+            .doFinally(new Action() {
+                @Override
+                public void run() throws Exception {
+                    outer.incrementAndGet();
+                }
+            })
+            .take(1)
+            .blockingSubscribe(Functions.emptyConsumer(), new Consumer() {
+                @Override
+                public void accept(Throwable e) throws Exception {
+                    e.printStackTrace();
+                }
+            });
+        }
+
+        Thread.sleep(100);
+        assertEquals(inner.get(), outer.get());
+        assertEquals(n, inner.get());
+    }
+
+    Flowable createFlowable(final AtomicInteger inner) {
+        return Flowable.unsafeCreate(new Publisher() {
+            @Override
+            public void subscribe(Subscriber s) {
+                final SerializedSubscriber it = new SerializedSubscriber(s);
+                it.onSubscribe(new BooleanSubscription());
+                Schedulers.io().scheduleDirect(new Runnable() {
+                    @Override
+                    public void run() {
+                        it.onNext(1);
+                    }
+                }, 0, TimeUnit.MILLISECONDS);
+                Schedulers.io().scheduleDirect(new Runnable() {
+                    @Override
+                    public void run() {
+                        it.onNext(2);
+                    }
+                }, 0, TimeUnit.MILLISECONDS);
+            }
+        })
+        .doFinally(new Action() {
+            @Override
+            public void run() throws Exception {
+                inner.incrementAndGet();
+            }
+        });
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeLastTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeLastTest.java
index b0d1af43c7..3320650881 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeLastTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeLastTest.java
@@ -24,7 +24,6 @@
 import org.reactivestreams.Subscriber;
 
 import io.reactivex.*;
-import io.reactivex.Flowable;
 import io.reactivex.exceptions.TestException;
 import io.reactivex.functions.*;
 import io.reactivex.schedulers.Schedulers;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeLastTimedTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeLastTimedTest.java
index 4864cac7f6..5f2cda82ea 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeLastTimedTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeLastTimedTest.java
@@ -336,4 +336,27 @@ public Publisher apply(Flowable f) throws Exception {
     public void badRequest() {
         TestHelper.assertBadRequestReported(PublishProcessor.create().takeLast(1, TimeUnit.SECONDS));
     }
+
+    @Test
+    public void lastWindowIsFixedInTime() {
+        TimesteppingScheduler scheduler = new TimesteppingScheduler();
+        scheduler.stepEnabled = false;
+
+        PublishProcessor pp = PublishProcessor.create();
+
+        TestSubscriber ts = pp
+        .takeLast(2, TimeUnit.SECONDS, scheduler)
+        .test();
+
+        pp.onNext(1);
+        pp.onNext(2);
+        pp.onNext(3);
+        pp.onNext(4);
+
+        scheduler.stepEnabled = true;
+
+        pp.onComplete();
+
+        ts.assertResult(1, 2, 3, 4);
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeTest.java
index 91d4d4ea8b..59d049a7c0 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeUntilPredicateTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeUntilPredicateTest.java
index acba2b1294..72e08bd1b3 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeUntilPredicateTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeUntilPredicateTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.flowable;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeWhileTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeWhileTest.java
index 97eac27982..f99b7d1d86 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeWhileTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableTakeWhileTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.fail;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableThrottleFirstTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableThrottleFirstTest.java
index 2e5fd020e7..12fc35760e 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableThrottleFirstTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableThrottleFirstTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.flowable;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableTimeoutTests.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableTimeoutTests.java
index 7e4b97c899..5f6aa08fa6 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableTimeoutTests.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableTimeoutTests.java
@@ -15,7 +15,6 @@
 
 import static io.reactivex.internal.util.ExceptionHelper.timeoutMessage;
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableTimeoutWithSelectorTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableTimeoutWithSelectorTest.java
index 178e015413..d1ba19d32b 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableTimeoutWithSelectorTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableTimeoutWithSelectorTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableTimerTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableTimerTest.java
index e5b9c61de4..b02fea95b3 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableTimerTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableTimerTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableToListTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableToListTest.java
index ffa4d0eba3..08dc9c244d 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableToListTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableToListTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.flowable;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableUnsubscribeOnTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableUnsubscribeOnTest.java
index cd6f22ea56..36112023bb 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableUnsubscribeOnTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableUnsubscribeOnTest.java
@@ -73,7 +73,7 @@ public void subscribe(Subscriber t1) {
 
             System.out.println("unsubscribeThread: " + unsubscribeThread);
             System.out.println("subscribeThread.get(): " + subscribeThread.get());
-            assertTrue(unsubscribeThread == uiEventLoop.getThread());
+            assertSame(unsubscribeThread, uiEventLoop.getThread());
 
             ts.assertValues(1, 2);
             ts.assertTerminated();
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableWindowWithFlowableTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableWindowWithFlowableTest.java
index 919ca0e468..ce321df789 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableWindowWithFlowableTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableWindowWithFlowableTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableWindowWithSizeTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableWindowWithSizeTest.java
index b6fb51f6d2..af412d9a02 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableWindowWithSizeTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableWindowWithSizeTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableWindowWithStartEndFlowableTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableWindowWithStartEndFlowableTest.java
index c1d825afed..1d27381129 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableWindowWithStartEndFlowableTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableWindowWithStartEndFlowableTest.java
@@ -17,12 +17,13 @@
 
 import java.util.*;
 import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.*;
 import org.reactivestreams.*;
 
 import io.reactivex.*;
-import io.reactivex.exceptions.TestException;
+import io.reactivex.exceptions.*;
 import io.reactivex.functions.*;
 import io.reactivex.internal.functions.Functions;
 import io.reactivex.internal.subscriptions.BooleanSubscription;
@@ -254,8 +255,8 @@ public Flowable apply(Integer t) {
 
         ts.dispose();
 
-        // FIXME subject has subscribers because of the open window
-        assertTrue(open.hasSubscribers());
+        // Disposing the outer sequence stops the opening of new windows
+        assertFalse(open.hasSubscribers());
         // FIXME subject has subscribers because of the open window
         assertTrue(close.hasSubscribers());
     }
@@ -430,4 +431,58 @@ protected void subscribeActual(
             RxJavaPlugins.reset();
         }
     }
+
+    static Flowable flowableDisposed(final AtomicBoolean ref) {
+        return Flowable.just(1).concatWith(Flowable.never())
+                .doOnCancel(new Action() {
+                    @Override
+                    public void run() throws Exception {
+                        ref.set(true);
+                    }
+                });
+    }
+
+    @Test
+    public void mainAndBoundaryDisposeOnNoWindows() {
+        AtomicBoolean mainDisposed = new AtomicBoolean();
+        AtomicBoolean openDisposed = new AtomicBoolean();
+        final AtomicBoolean closeDisposed = new AtomicBoolean();
+
+        flowableDisposed(mainDisposed)
+        .window(flowableDisposed(openDisposed), new Function>() {
+            @Override
+            public Flowable apply(Integer v) throws Exception {
+                return flowableDisposed(closeDisposed);
+            }
+        })
+        .test()
+        .assertSubscribed()
+        .assertNoErrors()
+        .assertNotComplete()
+        .dispose();
+
+        assertTrue(mainDisposed.get());
+        assertTrue(openDisposed.get());
+        assertTrue(closeDisposed.get());
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void mainWindowMissingBackpressure() {
+        PublishProcessor source = PublishProcessor.create();
+        PublishProcessor boundary = PublishProcessor.create();
+
+        TestSubscriber> ts = source.window(boundary, Functions.justFunction(Flowable.never()))
+        .test(0L)
+        ;
+
+        ts.assertEmpty();
+
+        boundary.onNext(1);
+
+        ts.assertFailure(MissingBackpressureException.class);
+
+        assertFalse(source.hasSubscribers());
+        assertFalse(boundary.hasSubscribers());
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableWindowWithTimeTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableWindowWithTimeTest.java
index 157faae1a5..56e1a736e6 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableWindowWithTimeTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableWindowWithTimeTest.java
@@ -16,7 +16,7 @@
 import static org.junit.Assert.*;
 
 import java.util.*;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 
 import org.junit.*;
@@ -64,17 +64,19 @@ public void subscribe(Subscriber subscriber) {
         Flowable> windowed = source.window(100, TimeUnit.MILLISECONDS, scheduler, 2);
         windowed.subscribe(observeWindow(list, lists));
 
-        scheduler.advanceTimeTo(100, TimeUnit.MILLISECONDS);
+        scheduler.advanceTimeTo(95, TimeUnit.MILLISECONDS);
         assertEquals(1, lists.size());
         assertEquals(lists.get(0), list("one", "two"));
 
-        scheduler.advanceTimeTo(200, TimeUnit.MILLISECONDS);
-        assertEquals(2, lists.size());
-        assertEquals(lists.get(1), list("three", "four"));
+        scheduler.advanceTimeTo(195, TimeUnit.MILLISECONDS);
+        assertEquals(3, lists.size());
+        assertTrue(lists.get(1).isEmpty());
+        assertEquals(lists.get(2), list("three", "four"));
 
         scheduler.advanceTimeTo(300, TimeUnit.MILLISECONDS);
-        assertEquals(3, lists.size());
-        assertEquals(lists.get(2), list("five"));
+        assertEquals(5, lists.size());
+        assertTrue(lists.get(3).isEmpty());
+        assertEquals(lists.get(4), list("five"));
     }
 
     @Test
@@ -916,5 +918,244 @@ public void nextWindowMissingBackpressureDrainOnTime() {
         .assertError(MissingBackpressureException.class)
         .assertNotComplete();
     }
-}
 
+    @Test
+    public void exactTimeBoundNoInterruptWindowOutputOnComplete() throws Exception {
+        final AtomicBoolean isInterrupted = new AtomicBoolean();
+
+        final PublishProcessor pp = PublishProcessor.create();
+
+        final CountDownLatch doOnNextDone = new CountDownLatch(1);
+        final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
+
+        pp.window(100, TimeUnit.MILLISECONDS)
+        .doOnNext(new Consumer>() {
+            int count;
+            @Override
+            public void accept(Flowable v) throws Exception {
+                System.out.println(Thread.currentThread());
+                if (count++ == 1) {
+                    secondWindowProcessing.countDown();
+                    try {
+                        Thread.sleep(200);
+                        isInterrupted.set(Thread.interrupted());
+                    } catch (InterruptedException ex) {
+                        isInterrupted.set(true);
+                    }
+                    doOnNextDone.countDown();
+                }
+            }
+        })
+        .test();
+
+        pp.onNext(1);
+
+        assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
+
+        pp.onComplete();
+
+        assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
+
+        assertFalse("The doOnNext got interrupted!", isInterrupted.get());
+    }
+
+    @Test
+    public void exactTimeBoundNoInterruptWindowOutputOnError() throws Exception {
+        final AtomicBoolean isInterrupted = new AtomicBoolean();
+
+        final PublishProcessor pp = PublishProcessor.create();
+
+        final CountDownLatch doOnNextDone = new CountDownLatch(1);
+        final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
+
+        pp.window(100, TimeUnit.MILLISECONDS)
+        .doOnNext(new Consumer>() {
+            int count;
+            @Override
+            public void accept(Flowable v) throws Exception {
+                System.out.println(Thread.currentThread());
+                if (count++ == 1) {
+                    secondWindowProcessing.countDown();
+                    try {
+                        Thread.sleep(200);
+                        isInterrupted.set(Thread.interrupted());
+                    } catch (InterruptedException ex) {
+                        isInterrupted.set(true);
+                    }
+                    doOnNextDone.countDown();
+                }
+            }
+        })
+        .test();
+
+        pp.onNext(1);
+
+        assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
+
+        pp.onError(new TestException());
+
+        assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
+
+        assertFalse("The doOnNext got interrupted!", isInterrupted.get());
+    }
+
+    @Test
+    public void exactTimeAndSizeBoundNoInterruptWindowOutputOnComplete() throws Exception {
+        final AtomicBoolean isInterrupted = new AtomicBoolean();
+
+        final PublishProcessor pp = PublishProcessor.create();
+
+        final CountDownLatch doOnNextDone = new CountDownLatch(1);
+        final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
+
+        pp.window(100, TimeUnit.MILLISECONDS, 10)
+        .doOnNext(new Consumer>() {
+            int count;
+            @Override
+            public void accept(Flowable v) throws Exception {
+                System.out.println(Thread.currentThread());
+                if (count++ == 1) {
+                    secondWindowProcessing.countDown();
+                    try {
+                        Thread.sleep(200);
+                        isInterrupted.set(Thread.interrupted());
+                    } catch (InterruptedException ex) {
+                        isInterrupted.set(true);
+                    }
+                    doOnNextDone.countDown();
+                }
+            }
+        })
+        .test();
+
+        pp.onNext(1);
+
+        assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
+
+        pp.onComplete();
+
+        assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
+
+        assertFalse("The doOnNext got interrupted!", isInterrupted.get());
+    }
+
+    @Test
+    public void exactTimeAndSizeBoundNoInterruptWindowOutputOnError() throws Exception {
+        final AtomicBoolean isInterrupted = new AtomicBoolean();
+
+        final PublishProcessor pp = PublishProcessor.create();
+
+        final CountDownLatch doOnNextDone = new CountDownLatch(1);
+        final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
+
+        pp.window(100, TimeUnit.MILLISECONDS, 10)
+        .doOnNext(new Consumer>() {
+            int count;
+            @Override
+            public void accept(Flowable v) throws Exception {
+                System.out.println(Thread.currentThread());
+                if (count++ == 1) {
+                    secondWindowProcessing.countDown();
+                    try {
+                        Thread.sleep(200);
+                        isInterrupted.set(Thread.interrupted());
+                    } catch (InterruptedException ex) {
+                        isInterrupted.set(true);
+                    }
+                    doOnNextDone.countDown();
+                }
+            }
+        })
+        .test();
+
+        pp.onNext(1);
+
+        assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
+
+        pp.onError(new TestException());
+
+        assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
+
+        assertFalse("The doOnNext got interrupted!", isInterrupted.get());
+    }
+
+    @Test
+    public void skipTimeAndSizeBoundNoInterruptWindowOutputOnComplete() throws Exception {
+        final AtomicBoolean isInterrupted = new AtomicBoolean();
+
+        final PublishProcessor pp = PublishProcessor.create();
+
+        final CountDownLatch doOnNextDone = new CountDownLatch(1);
+        final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
+
+        pp.window(90, 100, TimeUnit.MILLISECONDS)
+        .doOnNext(new Consumer>() {
+            int count;
+            @Override
+            public void accept(Flowable v) throws Exception {
+                System.out.println(Thread.currentThread());
+                if (count++ == 1) {
+                    secondWindowProcessing.countDown();
+                    try {
+                        Thread.sleep(200);
+                        isInterrupted.set(Thread.interrupted());
+                    } catch (InterruptedException ex) {
+                        isInterrupted.set(true);
+                    }
+                    doOnNextDone.countDown();
+                }
+            }
+        })
+        .test();
+
+        pp.onNext(1);
+
+        assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
+
+        pp.onComplete();
+
+        assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
+
+        assertFalse("The doOnNext got interrupted!", isInterrupted.get());
+    }
+
+    @Test
+    public void skipTimeAndSizeBoundNoInterruptWindowOutputOnError() throws Exception {
+        final AtomicBoolean isInterrupted = new AtomicBoolean();
+
+        final PublishProcessor pp = PublishProcessor.create();
+
+        final CountDownLatch doOnNextDone = new CountDownLatch(1);
+        final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
+
+        pp.window(90, 100, TimeUnit.MILLISECONDS)
+        .doOnNext(new Consumer>() {
+            int count;
+            @Override
+            public void accept(Flowable v) throws Exception {
+                System.out.println(Thread.currentThread());
+                if (count++ == 1) {
+                    secondWindowProcessing.countDown();
+                    try {
+                        Thread.sleep(200);
+                        isInterrupted.set(Thread.interrupted());
+                    } catch (InterruptedException ex) {
+                        isInterrupted.set(true);
+                    }
+                    doOnNextDone.countDown();
+                }
+            }
+        })
+        .test();
+
+        pp.onNext(1);
+
+        assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
+
+        pp.onError(new TestException());
+
+        assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
+
+        assertFalse("The doOnNext got interrupted!", isInterrupted.get());
+    }
+}
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableWithLatestFromTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableWithLatestFromTest.java
index 070176bdb0..c534ddd990 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableWithLatestFromTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableWithLatestFromTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableZipIterableTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableZipIterableTest.java
index a86de18f52..2ca5481fc3 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableZipIterableTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableZipIterableTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableZipTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableZipTest.java
index ef1223d66a..ee691d93c2 100644
--- a/src/test/java/io/reactivex/internal/operators/flowable/FlowableZipTest.java
+++ b/src/test/java/io/reactivex/internal/operators/flowable/FlowableZipTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.flowable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.lang.reflect.*;
@@ -1895,4 +1894,34 @@ public Integer apply(Integer a, Integer b) throws Exception {
 
         ts.assertResult(4);
     }
+
+    @Test
+    public void firstErrorPreventsSecondSubscription() {
+        final AtomicInteger counter = new AtomicInteger();
+
+        List> flowableList = new ArrayList>();
+        flowableList.add(Flowable.create(new FlowableOnSubscribe() {
+            @Override
+            public void subscribe(FlowableEmitter e)
+                    throws Exception { throw new TestException(); }
+        }, BackpressureStrategy.MISSING));
+        flowableList.add(Flowable.create(new FlowableOnSubscribe() {
+            @Override
+            public void subscribe(FlowableEmitter e)
+                    throws Exception { counter.getAndIncrement(); }
+        }, BackpressureStrategy.MISSING));
+
+        Flowable.zip(flowableList,
+                new Function() {
+                    @Override
+                    public Object apply(Object[] a) throws Exception {
+                        return a;
+                    }
+                })
+        .test()
+        .assertFailure(TestException.class)
+        ;
+
+        assertEquals(0, counter.get());
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/maybe/MaybeAmbTest.java b/src/test/java/io/reactivex/internal/operators/maybe/MaybeAmbTest.java
index a50c685233..a701a279ab 100644
--- a/src/test/java/io/reactivex/internal/operators/maybe/MaybeAmbTest.java
+++ b/src/test/java/io/reactivex/internal/operators/maybe/MaybeAmbTest.java
@@ -16,15 +16,21 @@
 import static org.junit.Assert.*;
 
 import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.Test;
 
 import io.reactivex.*;
 import io.reactivex.disposables.Disposables;
 import io.reactivex.exceptions.TestException;
+import io.reactivex.functions.*;
+import io.reactivex.internal.functions.Functions;
 import io.reactivex.observers.TestObserver;
 import io.reactivex.plugins.RxJavaPlugins;
 import io.reactivex.processors.PublishProcessor;
+import io.reactivex.schedulers.Schedulers;
+import io.reactivex.subjects.*;
 
 public class MaybeAmbTest {
 
@@ -129,4 +135,122 @@ protected void subscribeActual(
 
         to.assertResult(1);
     }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void noWinnerSuccessDispose() throws Exception {
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            final AtomicBoolean interrupted = new AtomicBoolean();
+            final CountDownLatch cdl = new CountDownLatch(1);
+
+            Maybe.ambArray(
+                Maybe.just(1)
+                    .subscribeOn(Schedulers.single())
+                    .observeOn(Schedulers.computation()),
+                Maybe.never()
+            )
+            .subscribe(new Consumer() {
+                @Override
+                public void accept(Object v) throws Exception {
+                    interrupted.set(Thread.currentThread().isInterrupted());
+                    cdl.countDown();
+                }
+            });
+
+            assertTrue(cdl.await(500, TimeUnit.SECONDS));
+            assertFalse("Interrupted!", interrupted.get());
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void noWinnerErrorDispose() throws Exception {
+        final TestException ex = new TestException();
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            final AtomicBoolean interrupted = new AtomicBoolean();
+            final CountDownLatch cdl = new CountDownLatch(1);
+
+            Maybe.ambArray(
+                Maybe.error(ex)
+                    .subscribeOn(Schedulers.single())
+                    .observeOn(Schedulers.computation()),
+                Maybe.never()
+            )
+            .subscribe(Functions.emptyConsumer(), new Consumer() {
+                @Override
+                public void accept(Throwable e) throws Exception {
+                    interrupted.set(Thread.currentThread().isInterrupted());
+                    cdl.countDown();
+                }
+            });
+
+            assertTrue(cdl.await(500, TimeUnit.SECONDS));
+            assertFalse("Interrupted!", interrupted.get());
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void noWinnerCompleteDispose() throws Exception {
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            final AtomicBoolean interrupted = new AtomicBoolean();
+            final CountDownLatch cdl = new CountDownLatch(1);
+
+            Maybe.ambArray(
+                Maybe.empty()
+                    .subscribeOn(Schedulers.single())
+                    .observeOn(Schedulers.computation()),
+                Maybe.never()
+            )
+            .subscribe(Functions.emptyConsumer(), Functions.emptyConsumer(), new Action() {
+                @Override
+                public void run() throws Exception {
+                    interrupted.set(Thread.currentThread().isInterrupted());
+                    cdl.countDown();
+                }
+            });
+
+            assertTrue(cdl.await(500, TimeUnit.SECONDS));
+            assertFalse("Interrupted!", interrupted.get());
+        }
+    }
+
+    @Test
+    public void nullSourceSuccessRace() {
+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+            List errors = TestHelper.trackPluginErrors();
+
+            try {
+
+                final Subject ps = ReplaySubject.create();
+                ps.onNext(1);
+
+                @SuppressWarnings("unchecked")
+                final Maybe source = Maybe.ambArray(ps.singleElement(),
+                        Maybe.never(), Maybe.never(), null);
+
+                Runnable r1 = new Runnable() {
+                    @Override
+                    public void run() {
+                        source.test();
+                    }
+                };
+
+                Runnable r2 = new Runnable() {
+                    @Override
+                    public void run() {
+                        ps.onComplete();
+                    }
+                };
+
+                TestHelper.race(r1, r2);
+
+                if (!errors.isEmpty()) {
+                    TestHelper.assertError(errors, 0, NullPointerException.class);
+                }
+            } finally {
+                RxJavaPlugins.reset();
+            }
+        }
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/maybe/MaybeDoOnTerminateTest.java b/src/test/java/io/reactivex/internal/operators/maybe/MaybeDoOnTerminateTest.java
new file mode 100644
index 0000000000..0e90e57731
--- /dev/null
+++ b/src/test/java/io/reactivex/internal/operators/maybe/MaybeDoOnTerminateTest.java
@@ -0,0 +1,122 @@
+/**
+ * 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.internal.operators.maybe;
+
+import io.reactivex.Maybe;
+import io.reactivex.TestHelper;
+import io.reactivex.exceptions.CompositeException;
+import io.reactivex.exceptions.TestException;
+import io.reactivex.functions.Action;
+import io.reactivex.observers.TestObserver;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static org.junit.Assert.assertTrue;
+
+public class MaybeDoOnTerminateTest {
+
+    @Test(expected = NullPointerException.class)
+    public void doOnTerminate() {
+        Maybe.just(1).doOnTerminate(null);
+    }
+
+    @Test
+    public void doOnTerminateSuccess() {
+        final AtomicBoolean atomicBoolean = new AtomicBoolean();
+        Maybe.just(1).doOnTerminate(new Action() {
+            @Override
+            public void run() {
+                atomicBoolean.set(true);
+            }
+        })
+        .test()
+        .assertResult(1);
+
+        assertTrue(atomicBoolean.get());
+    }
+
+    @Test
+    public void doOnTerminateError() {
+        final AtomicBoolean atomicBoolean = new AtomicBoolean();
+        Maybe.error(new TestException()).doOnTerminate(new Action() {
+            @Override
+            public void run() {
+                atomicBoolean.set(true);
+            }
+        })
+        .test()
+        .assertFailure(TestException.class);
+
+        assertTrue(atomicBoolean.get());
+    }
+
+    @Test
+    public void doOnTerminateComplete() {
+        final AtomicBoolean atomicBoolean = new AtomicBoolean();
+        Maybe.empty().doOnTerminate(new Action() {
+            @Override
+            public void run() {
+                atomicBoolean.set(true);
+            }
+        })
+        .test()
+        .assertResult();
+
+        assertTrue(atomicBoolean.get());
+    }
+
+    @Test
+    public void doOnTerminateSuccessCrash() {
+        Maybe.just(1).doOnTerminate(new Action() {
+            @Override
+            public void run() {
+                throw new TestException();
+            }
+        })
+        .test()
+        .assertFailure(TestException.class);
+    }
+
+    @Test
+    public void doOnTerminateErrorCrash() {
+        TestObserver to = Maybe.error(new TestException("Outer"))
+        .doOnTerminate(new Action() {
+            @Override
+            public void run() {
+                throw new TestException("Inner");
+            }
+        })
+        .test()
+        .assertFailure(CompositeException.class);
+
+        List errors = TestHelper.compositeList(to.errors().get(0));
+        TestHelper.assertError(errors, 0, TestException.class, "Outer");
+        TestHelper.assertError(errors, 1, TestException.class, "Inner");
+    }
+
+    @Test
+    public void doOnTerminateCompleteCrash() {
+        Maybe.empty()
+        .doOnTerminate(new Action() {
+            @Override
+            public void run() {
+                throw new TestException();
+            }
+        })
+        .test()
+        .assertFailure(TestException.class);
+    }
+}
diff --git a/src/test/java/io/reactivex/internal/operators/maybe/MaybeFromCallableTest.java b/src/test/java/io/reactivex/internal/operators/maybe/MaybeFromCallableTest.java
index 7a56347a32..44f50947ee 100644
--- a/src/test/java/io/reactivex/internal/operators/maybe/MaybeFromCallableTest.java
+++ b/src/test/java/io/reactivex/internal/operators/maybe/MaybeFromCallableTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.maybe;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableLatestTest.java b/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableLatestTest.java
index cdd95c58f2..27aa27ec2d 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableLatestTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableLatestTest.java
@@ -44,13 +44,13 @@ public void testSimple() {
         for (int i = 0; i < 9; i++) {
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
 
-            Assert.assertEquals(true, it.hasNext());
+            Assert.assertTrue(it.hasNext());
 
             Assert.assertEquals(Long.valueOf(i), it.next());
         }
 
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        Assert.assertEquals(false, it.hasNext());
+        Assert.assertFalse(it.hasNext());
     }
 
     @Test(timeout = 1000)
@@ -69,13 +69,13 @@ public void testSameSourceMultipleIterators() {
             for (int i = 0; i < 9; i++) {
                 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
 
-                Assert.assertEquals(true, it.hasNext());
+                Assert.assertTrue(it.hasNext());
 
                 Assert.assertEquals(Long.valueOf(i), it.next());
             }
 
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-            Assert.assertEquals(false, it.hasNext());
+            Assert.assertFalse(it.hasNext());
         }
     }
 
@@ -87,7 +87,7 @@ public void testEmpty() {
 
         Iterator it = iter.iterator();
 
-        Assert.assertEquals(false, it.hasNext());
+        Assert.assertFalse(it.hasNext());
 
         it.next();
     }
@@ -166,7 +166,7 @@ public void testFasterSource() {
         source.onNext(7);
         source.onComplete();
 
-        Assert.assertEquals(false, it.hasNext());
+        Assert.assertFalse(it.hasNext());
     }
 
     @Test(expected = UnsupportedOperationException.class)
diff --git a/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableMostRecentTest.java b/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableMostRecentTest.java
index 5a277d6ddd..a109beb2d7 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableMostRecentTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableMostRecentTest.java
@@ -28,7 +28,7 @@
 public class BlockingObservableMostRecentTest {
     @Test
     public void testMostRecentNull() {
-        assertEquals(null, Observable.never().blockingMostRecent(null).iterator().next());
+        assertNull(Observable.never().blockingMostRecent(null).iterator().next());
     }
 
     static  Iterable mostRecent(Observable source, T initialValue) {
@@ -91,12 +91,12 @@ public void testSingleSourceManyIterators() {
             for (int i = 0; i < 9; i++) {
                 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
 
-                Assert.assertEquals(true, it.hasNext());
+                Assert.assertTrue(it.hasNext());
                 Assert.assertEquals(Long.valueOf(i), it.next());
             }
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
 
-            Assert.assertEquals(false, it.hasNext());
+            Assert.assertFalse(it.hasNext());
         }
 
     }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableNextTest.java b/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableNextTest.java
index 2b8e670c16..b854c317b2 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableNextTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableNextTest.java
@@ -28,7 +28,6 @@
 import io.reactivex.exceptions.TestException;
 import io.reactivex.internal.operators.observable.BlockingObservableNext.NextObserver;
 import io.reactivex.plugins.RxJavaPlugins;
-import io.reactivex.processors.BehaviorProcessor;
 import io.reactivex.schedulers.Schedulers;
 import io.reactivex.subjects.*;
 
@@ -323,7 +322,7 @@ public void testSingleSourceManyIterators() throws InterruptedException {
             BlockingObservableNext.NextIterator it = (BlockingObservableNext.NextIterator)iter.iterator();
 
             for (long i = 0; i < 10; i++) {
-                Assert.assertEquals(true, it.hasNext());
+                Assert.assertTrue(it.hasNext());
                 Assert.assertEquals(j + "th iteration next", Long.valueOf(i), it.next());
             }
             terminal.onNext(1);
@@ -332,9 +331,9 @@ public void testSingleSourceManyIterators() throws InterruptedException {
 
     @Test
     public void testSynchronousNext() {
-        assertEquals(1, BehaviorProcessor.createDefault(1).take(1).blockingSingle().intValue());
-        assertEquals(2, BehaviorProcessor.createDefault(2).blockingIterable().iterator().next().intValue());
-        assertEquals(3, BehaviorProcessor.createDefault(3).blockingNext().iterator().next().intValue());
+        assertEquals(1, BehaviorSubject.createDefault(1).take(1).blockingSingle().intValue());
+        assertEquals(2, BehaviorSubject.createDefault(2).blockingIterable().iterator().next().intValue());
+        assertEquals(3, BehaviorSubject.createDefault(3).blockingNext().iterator().next().intValue());
     }
 
     @Test
diff --git a/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableToFutureTest.java b/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableToFutureTest.java
index f4fa707ee4..632d3dad72 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableToFutureTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableToFutureTest.java
@@ -121,6 +121,6 @@ public void testGetWithEmptyFlowable() throws Throwable {
     public void testGetWithASingleNullItem() throws Exception {
         Observable obs = Observable.just((String)null);
         Future f = obs.toFuture();
-        assertEquals(null, f.get());
+        assertNull(f.get());
     }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableToIteratorTest.java b/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableToIteratorTest.java
index af22e83993..324b7c2172 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableToIteratorTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/BlockingObservableToIteratorTest.java
@@ -16,15 +16,18 @@
 import static org.junit.Assert.*;
 
 import java.util.*;
+import java.util.concurrent.TimeUnit;
 
 import org.junit.*;
 
 import io.reactivex.Observable;
 import io.reactivex.ObservableSource;
 import io.reactivex.Observer;
-import io.reactivex.disposables.Disposables;
+import io.reactivex.disposables.*;
 import io.reactivex.exceptions.TestException;
 import io.reactivex.internal.operators.observable.BlockingObservableIterable.BlockingObservableIterator;
+import io.reactivex.schedulers.Schedulers;
+import io.reactivex.subjects.PublishSubject;
 
 public class BlockingObservableToIteratorTest {
 
@@ -34,16 +37,16 @@ public void testToIterator() {
 
         Iterator it = obs.blockingIterable().iterator();
 
-        assertEquals(true, it.hasNext());
+        assertTrue(it.hasNext());
         assertEquals("one", it.next());
 
-        assertEquals(true, it.hasNext());
+        assertTrue(it.hasNext());
         assertEquals("two", it.next());
 
-        assertEquals(true, it.hasNext());
+        assertTrue(it.hasNext());
         assertEquals("three", it.next());
 
-        assertEquals(false, it.hasNext());
+        assertFalse(it.hasNext());
 
     }
 
@@ -61,10 +64,10 @@ public void subscribe(Observer observer) {
 
         Iterator it = obs.blockingIterable().iterator();
 
-        assertEquals(true, it.hasNext());
+        assertTrue(it.hasNext());
         assertEquals("one", it.next());
 
-        assertEquals(true, it.hasNext());
+        assertTrue(it.hasNext());
         it.next();
     }
 
@@ -119,4 +122,28 @@ public void remove() {
         BlockingObservableIterator it = new BlockingObservableIterator(128);
         it.remove();
     }
+
+    @Test(expected = NoSuchElementException.class)
+    public void disposedIteratorHasNextReturns() {
+        Iterator it = PublishSubject.create()
+                .blockingIterable().iterator();
+        ((Disposable)it).dispose();
+        assertFalse(it.hasNext());
+        it.next();
+    }
+
+    @Test
+    public void asyncDisposeUnblocks() {
+        final Iterator it = PublishSubject.create()
+                .blockingIterable().iterator();
+
+        Schedulers.single().scheduleDirect(new Runnable() {
+            @Override
+            public void run() {
+                ((Disposable)it).dispose();
+            }
+        }, 1, TimeUnit.SECONDS);
+
+        assertFalse(it.hasNext());
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableAllTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableAllTest.java
index dc8445068c..e53fd7161c 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableAllTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableAllTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableAmbTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableAmbTest.java
index ee4d58adf5..a76b8f22e6 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableAmbTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableAmbTest.java
@@ -18,8 +18,8 @@
 
 import java.io.IOException;
 import java.util.*;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
 
 import org.junit.*;
 import org.mockito.InOrder;
@@ -29,7 +29,8 @@
 import io.reactivex.Observer;
 import io.reactivex.disposables.*;
 import io.reactivex.exceptions.TestException;
-import io.reactivex.functions.Consumer;
+import io.reactivex.functions.*;
+import io.reactivex.internal.functions.Functions;
 import io.reactivex.observers.TestObserver;
 import io.reactivex.plugins.RxJavaPlugins;
 import io.reactivex.schedulers.*;
@@ -263,6 +264,23 @@ public void singleIterable() {
         .assertResult(1);
     }
 
+    /**
+     * Ensures that an ObservableSource implementation can be supplied that doesn't subclass Observable
+     */
+    @Test
+    public void singleIterableNotSubclassingObservable() {
+        final ObservableSource s1 = new ObservableSource() {
+            @Override
+            public void subscribe (final Observer observer) {
+                Observable.just(1).subscribe(observer);
+            }
+        };
+
+        Observable.amb(Collections.singletonList(s1))
+        .test()
+        .assertResult(1);
+    }
+
     @SuppressWarnings("unchecked")
     @Test
     public void disposed() {
@@ -383,4 +401,84 @@ public void ambArrayOrder() {
         Observable error = Observable.error(new RuntimeException());
         Observable.ambArray(Observable.just(1), error).test().assertValue(1).assertComplete();
     }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void noWinnerSuccessDispose() throws Exception {
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            final AtomicBoolean interrupted = new AtomicBoolean();
+            final CountDownLatch cdl = new CountDownLatch(1);
+
+            Observable.ambArray(
+                Observable.just(1)
+                    .subscribeOn(Schedulers.single())
+                    .observeOn(Schedulers.computation()),
+                Observable.never()
+            )
+            .subscribe(new Consumer() {
+                @Override
+                public void accept(Object v) throws Exception {
+                    interrupted.set(Thread.currentThread().isInterrupted());
+                    cdl.countDown();
+                }
+            });
+
+            assertTrue(cdl.await(500, TimeUnit.SECONDS));
+            assertFalse("Interrupted!", interrupted.get());
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void noWinnerErrorDispose() throws Exception {
+        final TestException ex = new TestException();
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            final AtomicBoolean interrupted = new AtomicBoolean();
+            final CountDownLatch cdl = new CountDownLatch(1);
+
+            Observable.ambArray(
+                Observable.error(ex)
+                    .subscribeOn(Schedulers.single())
+                    .observeOn(Schedulers.computation()),
+                Observable.never()
+            )
+            .subscribe(Functions.emptyConsumer(), new Consumer() {
+                @Override
+                public void accept(Throwable e) throws Exception {
+                    interrupted.set(Thread.currentThread().isInterrupted());
+                    cdl.countDown();
+                }
+            });
+
+            assertTrue(cdl.await(500, TimeUnit.SECONDS));
+            assertFalse("Interrupted!", interrupted.get());
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void noWinnerCompleteDispose() throws Exception {
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            final AtomicBoolean interrupted = new AtomicBoolean();
+            final CountDownLatch cdl = new CountDownLatch(1);
+
+            Observable.ambArray(
+                Observable.empty()
+                    .subscribeOn(Schedulers.single())
+                    .observeOn(Schedulers.computation()),
+                Observable.never()
+            )
+            .subscribe(Functions.emptyConsumer(), Functions.emptyConsumer(), new Action() {
+                @Override
+                public void run() throws Exception {
+                    interrupted.set(Thread.currentThread().isInterrupted());
+                    cdl.countDown();
+                }
+            });
+
+            assertTrue(cdl.await(500, TimeUnit.SECONDS));
+            assertFalse("Interrupted!", interrupted.get());
+        }
+    }
+
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableAnyTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableAnyTest.java
index 7c66cba3f6..fcdc13fee9 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableAnyTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableAnyTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableBufferTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableBufferTest.java
index 43612b228d..16ba2fab6d 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableBufferTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableBufferTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
@@ -2136,4 +2135,20 @@ public ObservableSource> apply(Observable o)
             }
         });
     }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void bufferExactFailingSupplier() {
+        Observable.empty()
+                .buffer(1, TimeUnit.SECONDS, Schedulers.computation(), 10, new Callable>() {
+                    @Override
+                    public List call() throws Exception {
+                        throw new TestException();
+                    }
+                }, false)
+                .test()
+                .awaitDone(1, TimeUnit.SECONDS)
+                .assertFailure(TestException.class)
+        ;
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableCombineLatestTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableCombineLatestTest.java
index 55256bccd8..736a0bd9b5 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableCombineLatestTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableCombineLatestTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
@@ -788,6 +787,34 @@ public Object apply(Object[] a) throws Exception {
         .assertResult("[1, 2]");
     }
 
+    /**
+     * Ensures that an ObservableSource implementation can be supplied that doesn't subclass Observable
+     */
+    @Test
+    public void combineLatestIterableOfSourcesNotSubclassingObservable() {
+        final ObservableSource s1 = new ObservableSource() {
+            @Override
+            public void subscribe (final Observer observer) {
+                Observable.just(1).subscribe(observer);
+            }
+        };
+        final ObservableSource s2 = new ObservableSource() {
+            @Override
+            public void subscribe (final Observer observer) {
+                Observable.just(2).subscribe(observer);
+            }
+        };
+
+        Observable.combineLatest(Arrays.asList(s1, s2), new Function() {
+            @Override
+            public Object apply(Object[] a) throws Exception {
+                return Arrays.toString(a);
+            }
+        })
+        .test()
+        .assertResult("[1, 2]");
+    }
+
     @Test
     @SuppressWarnings("unchecked")
     public void combineLatestDelayErrorArrayOfSources() {
@@ -1217,4 +1244,5 @@ public Object apply(Object[] a) throws Exception {
         .awaitDone(5, TimeUnit.SECONDS)
         .assertFailure(TestException.class, 42);
     }
+
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableConcatMapEagerTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableConcatMapEagerTest.java
index 3959fab45e..17e418bab7 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableConcatMapEagerTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableConcatMapEagerTest.java
@@ -1141,4 +1141,37 @@ public void arrayDelayErrorMaxConcurrencyErrorDelayed() {
 
         to.assertFailure(TestException.class, 1, 2);
     }
+
+    @Test
+    public void cancelActive() {
+        PublishSubject ps1 = PublishSubject.create();
+        PublishSubject ps2 = PublishSubject.create();
+
+        TestObserver to = Observable
+                .concatEager(Observable.just(ps1, ps2))
+                .test();
+
+        assertTrue(ps1.hasObservers());
+        assertTrue(ps2.hasObservers());
+
+        to.dispose();
+
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+    }
+
+    @Test
+    public void cancelNoInnerYet() {
+        PublishSubject> ps1 = PublishSubject.create();
+
+        TestObserver to = Observable
+                .concatEager(ps1)
+                .test();
+
+        assertTrue(ps1.hasObservers());
+
+        to.dispose();
+
+        assertFalse(ps1.hasObservers());
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableDebounceTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableDebounceTest.java
index 01bf61ac6e..aa24f68cd9 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableDebounceTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableDebounceTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
@@ -505,4 +504,14 @@ public void timedError() {
         .test()
         .assertFailure(TestException.class);
     }
+
+    @Test
+    public void debounceOnEmpty() {
+        Observable.empty().debounce(new Function>() {
+            @Override
+            public ObservableSource apply(Object o) {
+                return Observable.just(new Object());
+            }
+        }).subscribe();
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableDelayTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableDelayTest.java
index 1088f2abc1..40e396b314 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableDelayTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableDelayTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableDematerializeTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableDematerializeTest.java
index d815a70ea5..d2c5a4ca57 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableDematerializeTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableDematerializeTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.observable;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableDistinctTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableDistinctTest.java
index 8114d64f9a..67f73d3ede 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableDistinctTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableDistinctTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableDistinctUntilChangedTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableDistinctUntilChangedTest.java
index b0ba634354..6bd333e814 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableDistinctUntilChangedTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableDistinctUntilChangedTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.observable;
 
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableDoOnEachTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableDoOnEachTest.java
index 161ae3db9e..a22c969c9b 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableDoOnEachTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableDoOnEachTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableFilterTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableFilterTest.java
index e855c07820..7ac6418db7 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableFilterTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableFilterTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.observable;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import org.junit.Test;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableFlatMapTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableFlatMapTest.java
index 960722060a..61fbd21c7f 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableFlatMapTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableFlatMapTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
@@ -1085,4 +1084,61 @@ public void accept(Integer v) throws Exception {
         assertFalse(ps3.hasObservers());
         assertFalse(ps4.hasObservers());
     }
+
+    @Test
+    public void mainErrorsInnerCancelled() {
+        PublishSubject ps1 = PublishSubject.create();
+        PublishSubject ps2 = PublishSubject.create();
+
+        ps1
+        .flatMap(Functions.justFunction(ps2))
+        .test();
+
+        ps1.onNext(1);
+        assertTrue("No subscribers?", ps2.hasObservers());
+
+        ps1.onError(new TestException());
+
+        assertFalse("Has subscribers?", ps2.hasObservers());
+    }
+
+    @Test
+    public void innerErrorsMainCancelled() {
+        PublishSubject ps1 = PublishSubject.create();
+        PublishSubject ps2 = PublishSubject.create();
+
+        ps1
+        .flatMap(Functions.justFunction(ps2))
+        .test();
+
+        ps1.onNext(1);
+        assertTrue("No subscribers?", ps2.hasObservers());
+
+        ps2.onError(new TestException());
+
+        assertFalse("Has subscribers?", ps1.hasObservers());
+    }
+
+    @Test(timeout = 5000)
+    public void mixedScalarAsync() {
+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+            Observable
+            .range(0, 20)
+            .flatMap(new Function>() {
+                @Override
+                public ObservableSource apply(Integer integer) throws Exception {
+                    if (integer % 5 != 0) {
+                        return Observable
+                                .just(integer);
+                    }
+
+                    return Observable
+                            .just(-integer)
+                            .observeOn(Schedulers.computation());
+                }
+            }, false, 1)
+            .ignoreElements()
+            .blockingAwait();
+        }
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableFromCallableTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableFromCallableTest.java
index 542165907f..c10d53db36 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableFromCallableTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableFromCallableTest.java
@@ -17,7 +17,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableFromIterableTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableFromIterableTest.java
index 3b0a9d4970..5ed25eb269 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableFromIterableTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableFromIterableTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableGroupByTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableGroupByTest.java
index 42f441bd10..31bb5cf6a0 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableGroupByTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableGroupByTest.java
@@ -1364,7 +1364,7 @@ public void accept(String s) {
                 });
             }
         });
-        assertEquals(null, key[0]);
+        assertNull(key[0]);
         assertEquals(Arrays.asList("a", "b", "c"), values);
     }
 
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableGroupJoinTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableGroupJoinTest.java
index 3f902cb4a4..59c5a96332 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableGroupJoinTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableGroupJoinTest.java
@@ -16,7 +16,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableJoinTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableJoinTest.java
index 8ced523827..00a733959d 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableJoinTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableJoinTest.java
@@ -15,7 +15,6 @@
  */
 package io.reactivex.internal.operators.observable;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableLastTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableLastTest.java
index 6f3ecd39c8..77f02bfe71 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableLastTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableLastTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.NoSuchElementException;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableMapTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableMapTest.java
index 3d824be862..4d271a4197 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableMapTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableMapTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.assertNull;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableMergeWithCompletableTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableMergeWithCompletableTest.java
index 872509e164..d9a54c916a 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableMergeWithCompletableTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableMergeWithCompletableTest.java
@@ -135,4 +135,40 @@ protected void subscribeActual(Observer observer) {
         .test()
         .assertResult(1);
     }
+
+    @Test
+    public void cancelOtherOnMainError() {
+        PublishSubject ps = PublishSubject.create();
+        CompletableSubject cs = CompletableSubject.create();
+
+        TestObserver to = ps.mergeWith(cs).test();
+
+        assertTrue(ps.hasObservers());
+        assertTrue(cs.hasObservers());
+
+        ps.onError(new TestException());
+
+        to.assertFailure(TestException.class);
+
+        assertFalse("main has observers!", ps.hasObservers());
+        assertFalse("other has observers", cs.hasObservers());
+    }
+
+    @Test
+    public void cancelMainOnOtherError() {
+        PublishSubject ps = PublishSubject.create();
+        CompletableSubject cs = CompletableSubject.create();
+
+        TestObserver to = ps.mergeWith(cs).test();
+
+        assertTrue(ps.hasObservers());
+        assertTrue(cs.hasObservers());
+
+        cs.onError(new TestException());
+
+        to.assertFailure(TestException.class);
+
+        assertFalse("main has observers!", ps.hasObservers());
+        assertFalse("other has observers", cs.hasObservers());
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableMergeWithMaybeTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableMergeWithMaybeTest.java
index a70e4c2fa8..ee9eb9b576 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableMergeWithMaybeTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableMergeWithMaybeTest.java
@@ -272,4 +272,39 @@ public void onNext(Integer t) {
         to.assertResult(0, 1, 2, 3, 4);
     }
 
+    @Test
+    public void cancelOtherOnMainError() {
+        PublishSubject ps = PublishSubject.create();
+        MaybeSubject ms = MaybeSubject.create();
+
+        TestObserver to = ps.mergeWith(ms).test();
+
+        assertTrue(ps.hasObservers());
+        assertTrue(ms.hasObservers());
+
+        ps.onError(new TestException());
+
+        to.assertFailure(TestException.class);
+
+        assertFalse("main has observers!", ps.hasObservers());
+        assertFalse("other has observers", ms.hasObservers());
+    }
+
+    @Test
+    public void cancelMainOnOtherError() {
+        PublishSubject ps = PublishSubject.create();
+        MaybeSubject ms = MaybeSubject.create();
+
+        TestObserver to = ps.mergeWith(ms).test();
+
+        assertTrue(ps.hasObservers());
+        assertTrue(ms.hasObservers());
+
+        ms.onError(new TestException());
+
+        to.assertFailure(TestException.class);
+
+        assertFalse("main has observers!", ps.hasObservers());
+        assertFalse("other has observers", ms.hasObservers());
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableMergeWithSingleTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableMergeWithSingleTest.java
index 25ce78d486..0d8fb3432b 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableMergeWithSingleTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableMergeWithSingleTest.java
@@ -263,4 +263,40 @@ public void onNext(Integer t) {
 
         to.assertResult(0, 1, 2, 3, 4);
     }
+
+    @Test
+    public void cancelOtherOnMainError() {
+        PublishSubject ps = PublishSubject.create();
+        SingleSubject ss = SingleSubject.create();
+
+        TestObserver to = ps.mergeWith(ss).test();
+
+        assertTrue(ps.hasObservers());
+        assertTrue(ss.hasObservers());
+
+        ps.onError(new TestException());
+
+        to.assertFailure(TestException.class);
+
+        assertFalse("main has observers!", ps.hasObservers());
+        assertFalse("other has observers", ss.hasObservers());
+    }
+
+    @Test
+    public void cancelMainOnOtherError() {
+        PublishSubject ps = PublishSubject.create();
+        SingleSubject ss = SingleSubject.create();
+
+        TestObserver to = ps.mergeWith(ss).test();
+
+        assertTrue(ps.hasObservers());
+        assertTrue(ss.hasObservers());
+
+        ss.onError(new TestException());
+
+        to.assertFailure(TestException.class);
+
+        assertFalse("main has observers!", ps.hasObservers());
+        assertFalse("other has observers", ss.hasObservers());
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableObserveOnTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableObserveOnTest.java
index 8d948b2592..48cbe91908 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableObserveOnTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableObserveOnTest.java
@@ -29,7 +29,7 @@
 import io.reactivex.Observer;
 import io.reactivex.annotations.Nullable;
 import io.reactivex.disposables.*;
-import io.reactivex.exceptions.TestException;
+import io.reactivex.exceptions.*;
 import io.reactivex.functions.*;
 import io.reactivex.internal.fuseable.*;
 import io.reactivex.internal.operators.flowable.FlowableObserveOnTest.DisposeTrackingScheduler;
@@ -814,4 +814,36 @@ public void workerNotDisposedPrematurelyNormalInAsyncOut() {
         assertEquals(1, s.disposedCount.get());
     }
 
+    @Test
+    public void fusedNoConcurrentCleanDueToCancel() {
+        for (int j = 0; j < TestHelper.RACE_LONG_LOOPS; j++) {
+            List errors = TestHelper.trackPluginErrors();
+            try {
+                final UnicastSubject us = UnicastSubject.create();
+
+                TestObserver to = us.hide()
+                .observeOn(Schedulers.io())
+                .observeOn(Schedulers.single())
+                .unsubscribeOn(Schedulers.computation())
+                .firstOrError()
+                .test();
+
+                for (int i = 0; us.hasObservers() && i < 10000; i++) {
+                    us.onNext(i);
+                }
+
+                to
+                .awaitDone(5, TimeUnit.SECONDS)
+                ;
+
+                if (!errors.isEmpty()) {
+                    throw new CompositeException(errors);
+                }
+
+                to.assertResult(0);
+            } finally {
+                RxJavaPlugins.reset();
+            }
+        }
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableOnErrorResumeNextViaFunctionTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableOnErrorResumeNextViaFunctionTest.java
index b8b3f67f1e..fa48b217f8 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableOnErrorResumeNextViaFunctionTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableOnErrorResumeNextViaFunctionTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservablePublishAltTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservablePublishAltTest.java
new file mode 100644
index 0000000000..b268e5b2ed
--- /dev/null
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservablePublishAltTest.java
@@ -0,0 +1,794 @@
+/**
+ * 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.internal.operators.observable;
+
+import static org.junit.Assert.*;
+
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
+
+import org.junit.Test;
+
+import io.reactivex.*;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.*;
+import io.reactivex.exceptions.TestException;
+import io.reactivex.functions.*;
+import io.reactivex.internal.functions.Functions;
+import io.reactivex.internal.fuseable.HasUpstreamObservableSource;
+import io.reactivex.observables.ConnectableObservable;
+import io.reactivex.observers.TestObserver;
+import io.reactivex.plugins.RxJavaPlugins;
+import io.reactivex.schedulers.*;
+import io.reactivex.subjects.PublishSubject;
+
+public class ObservablePublishAltTest {
+
+    @Test
+    public void testPublish() throws InterruptedException {
+        final AtomicInteger counter = new AtomicInteger();
+        ConnectableObservable o = Observable.unsafeCreate(new ObservableSource() {
+
+            @Override
+            public void subscribe(final Observer observer) {
+                observer.onSubscribe(Disposables.empty());
+                new Thread(new Runnable() {
+
+                    @Override
+                    public void run() {
+                        counter.incrementAndGet();
+                        observer.onNext("one");
+                        observer.onComplete();
+                    }
+                }).start();
+            }
+        }).publish();
+
+        final CountDownLatch latch = new CountDownLatch(2);
+
+        // subscribe once
+        o.subscribe(new Consumer() {
+
+            @Override
+            public void accept(String v) {
+                assertEquals("one", v);
+                latch.countDown();
+            }
+        });
+
+        // subscribe again
+        o.subscribe(new Consumer() {
+
+            @Override
+            public void accept(String v) {
+                assertEquals("one", v);
+                latch.countDown();
+            }
+        });
+
+        Disposable connection = o.connect();
+        try {
+            if (!latch.await(1000, TimeUnit.MILLISECONDS)) {
+                fail("subscriptions did not receive values");
+            }
+            assertEquals(1, counter.get());
+        } finally {
+            connection.dispose();
+        }
+    }
+
+    @Test
+    public void testBackpressureFastSlow() {
+        ConnectableObservable is = Observable.range(1, Flowable.bufferSize() * 2).publish();
+        Observable fast = is.observeOn(Schedulers.computation())
+        .doOnComplete(new Action() {
+            @Override
+            public void run() {
+                System.out.println("^^^^^^^^^^^^^ completed FAST");
+            }
+        });
+
+        Observable slow = is.observeOn(Schedulers.computation()).map(new Function() {
+            int c;
+
+            @Override
+            public Integer apply(Integer i) {
+                if (c == 0) {
+                    try {
+                        Thread.sleep(500);
+                    } catch (InterruptedException e) {
+                    }
+                }
+                c++;
+                return i;
+            }
+
+        }).doOnComplete(new Action() {
+
+            @Override
+            public void run() {
+                System.out.println("^^^^^^^^^^^^^ completed SLOW");
+            }
+
+        });
+
+        TestObserver to = new TestObserver();
+        Observable.merge(fast, slow).subscribe(to);
+        is.connect();
+        to.awaitTerminalEvent();
+        to.assertNoErrors();
+        assertEquals(Flowable.bufferSize() * 4, to.valueCount());
+    }
+
+    // use case from https://github.com/ReactiveX/RxJava/issues/1732
+    @Test
+    public void testTakeUntilWithPublishedStreamUsingSelector() {
+        final AtomicInteger emitted = new AtomicInteger();
+        Observable xs = Observable.range(0, Flowable.bufferSize() * 2).doOnNext(new Consumer() {
+
+            @Override
+            public void accept(Integer t1) {
+                emitted.incrementAndGet();
+            }
+
+        });
+        TestObserver to = new TestObserver();
+        xs.publish(new Function, Observable>() {
+
+            @Override
+            public Observable apply(Observable xs) {
+                return xs.takeUntil(xs.skipWhile(new Predicate() {
+
+                    @Override
+                    public boolean test(Integer i) {
+                        return i <= 3;
+                    }
+
+                }));
+            }
+
+        }).subscribe(to);
+        to.awaitTerminalEvent();
+        to.assertNoErrors();
+        to.assertValues(0, 1, 2, 3);
+        assertEquals(5, emitted.get());
+        System.out.println(to.values());
+    }
+
+    // use case from https://github.com/ReactiveX/RxJava/issues/1732
+    @Test
+    public void testTakeUntilWithPublishedStream() {
+        Observable xs = Observable.range(0, Flowable.bufferSize() * 2);
+        TestObserver to = new TestObserver();
+        ConnectableObservable xsp = xs.publish();
+        xsp.takeUntil(xsp.skipWhile(new Predicate() {
+
+            @Override
+            public boolean test(Integer i) {
+                return i <= 3;
+            }
+
+        })).subscribe(to);
+        xsp.connect();
+        System.out.println(to.values());
+    }
+
+    @Test(timeout = 10000)
+    public void testBackpressureTwoConsumers() {
+        final AtomicInteger sourceEmission = new AtomicInteger();
+        final AtomicBoolean sourceUnsubscribed = new AtomicBoolean();
+        final Observable source = Observable.range(1, 100)
+                .doOnNext(new Consumer() {
+                    @Override
+                    public void accept(Integer t1) {
+                        sourceEmission.incrementAndGet();
+                    }
+                })
+                .doOnDispose(new Action() {
+                    @Override
+                    public void run() {
+                        sourceUnsubscribed.set(true);
+                    }
+                }).share();
+        ;
+
+        final AtomicBoolean child1Unsubscribed = new AtomicBoolean();
+        final AtomicBoolean child2Unsubscribed = new AtomicBoolean();
+
+        final TestObserver to2 = new TestObserver();
+
+        final TestObserver to1 = new TestObserver() {
+            @Override
+            public void onNext(Integer t) {
+                if (valueCount() == 2) {
+                    source.doOnDispose(new Action() {
+                        @Override
+                        public void run() {
+                            child2Unsubscribed.set(true);
+                        }
+                    }).take(5).subscribe(to2);
+                }
+                super.onNext(t);
+            }
+        };
+
+        source.doOnDispose(new Action() {
+            @Override
+            public void run() {
+                child1Unsubscribed.set(true);
+            }
+        }).take(5)
+        .subscribe(to1);
+
+        to1.awaitTerminalEvent();
+        to2.awaitTerminalEvent();
+
+        to1.assertNoErrors();
+        to2.assertNoErrors();
+
+        assertTrue(sourceUnsubscribed.get());
+        assertTrue(child1Unsubscribed.get());
+        assertTrue(child2Unsubscribed.get());
+
+        to1.assertValues(1, 2, 3, 4, 5);
+        to2.assertValues(4, 5, 6, 7, 8);
+
+        assertEquals(8, sourceEmission.get());
+    }
+
+    @Test
+    public void testConnectWithNoSubscriber() {
+        TestScheduler scheduler = new TestScheduler();
+        ConnectableObservable co = Observable.interval(10, 10, TimeUnit.MILLISECONDS, scheduler).take(3).publish();
+        co.connect();
+        // Emit 0
+        scheduler.advanceTimeBy(15, TimeUnit.MILLISECONDS);
+        TestObserver to = new TestObserver();
+        co.subscribe(to);
+        // Emit 1 and 2
+        scheduler.advanceTimeBy(50, TimeUnit.MILLISECONDS);
+        to.assertValues(1L, 2L);
+        to.assertNoErrors();
+        to.assertTerminated();
+    }
+
+    @Test
+    public void testSubscribeAfterDisconnectThenConnect() {
+        ConnectableObservable source = Observable.just(1).publish();
+
+        TestObserver to1 = new TestObserver();
+
+        source.subscribe(to1);
+
+        Disposable connection = source.connect();
+
+        to1.assertValue(1);
+        to1.assertNoErrors();
+        to1.assertTerminated();
+
+        TestObserver to2 = new TestObserver();
+
+        source.subscribe(to2);
+
+        Disposable connection2 = source.connect();
+
+        to2.assertValue(1);
+        to2.assertNoErrors();
+        to2.assertTerminated();
+
+        System.out.println(connection);
+        System.out.println(connection2);
+    }
+
+    @Test
+    public void testNoSubscriberRetentionOnCompleted() {
+        ObservablePublish source = (ObservablePublish)Observable.just(1).publish();
+
+        TestObserver to1 = new TestObserver();
+
+        source.subscribe(to1);
+
+        to1.assertNoValues();
+        to1.assertNoErrors();
+        to1.assertNotComplete();
+
+        source.connect();
+
+        to1.assertValue(1);
+        to1.assertNoErrors();
+        to1.assertTerminated();
+
+        assertNull(source.current.get());
+    }
+
+    @Test
+    public void testNonNullConnection() {
+        ConnectableObservable source = Observable.never().publish();
+
+        assertNotNull(source.connect());
+        assertNotNull(source.connect());
+    }
+
+    @Test
+    public void testNoDisconnectSomeoneElse() {
+        ConnectableObservable source = Observable.never().publish();
+
+        Disposable connection1 = source.connect();
+        Disposable connection2 = source.connect();
+
+        connection1.dispose();
+
+        Disposable connection3 = source.connect();
+
+        connection2.dispose();
+
+        assertTrue(checkPublishDisposed(connection1));
+        assertTrue(checkPublishDisposed(connection2));
+        assertFalse(checkPublishDisposed(connection3));
+    }
+
+    @SuppressWarnings("unchecked")
+    static boolean checkPublishDisposed(Disposable d) {
+        return ((ObservablePublish.PublishObserver)d).isDisposed();
+    }
+
+    @Test
+    public void testConnectIsIdempotent() {
+        final AtomicInteger calls = new AtomicInteger();
+        Observable source = Observable.unsafeCreate(new ObservableSource() {
+            @Override
+            public void subscribe(Observer t) {
+                t.onSubscribe(Disposables.empty());
+                calls.getAndIncrement();
+            }
+        });
+
+        ConnectableObservable conn = source.publish();
+
+        assertEquals(0, calls.get());
+
+        conn.connect();
+        conn.connect();
+
+        assertEquals(1, calls.get());
+
+        conn.connect().dispose();
+
+        conn.connect();
+        conn.connect();
+
+        assertEquals(2, calls.get());
+    }
+
+    @Test
+    public void testObserveOn() {
+        ConnectableObservable co = Observable.range(0, 1000).publish();
+        Observable obs = co.observeOn(Schedulers.computation());
+        for (int i = 0; i < 1000; i++) {
+            for (int j = 1; j < 6; j++) {
+                List> tos = new ArrayList>();
+                for (int k = 1; k < j; k++) {
+                    TestObserver to = new TestObserver();
+                    tos.add(to);
+                    obs.subscribe(to);
+                }
+
+                Disposable connection = co.connect();
+
+                for (TestObserver to : tos) {
+                    to.awaitTerminalEvent(2, TimeUnit.SECONDS);
+                    to.assertTerminated();
+                    to.assertNoErrors();
+                    assertEquals(1000, to.valueCount());
+                }
+                connection.dispose();
+            }
+        }
+    }
+
+    @Test
+    public void preNextConnect() {
+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+
+            final ConnectableObservable co = Observable.empty().publish();
+
+            co.connect();
+
+            Runnable r1 = new Runnable() {
+                @Override
+                public void run() {
+                    co.test();
+                }
+            };
+
+            TestHelper.race(r1, r1);
+        }
+    }
+
+    @Test
+    public void connectRace() {
+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+
+            final ConnectableObservable co = Observable.empty().publish();
+
+            Runnable r1 = new Runnable() {
+                @Override
+                public void run() {
+                    co.connect();
+                }
+            };
+
+            TestHelper.race(r1, r1);
+        }
+    }
+
+    @Test
+    public void selectorCrash() {
+        Observable.just(1).publish(new Function, ObservableSource>() {
+            @Override
+            public ObservableSource apply(Observable v) throws Exception {
+                throw new TestException();
+            }
+        })
+        .test()
+        .assertFailure(TestException.class);
+    }
+
+    @Test
+    public void source() {
+        Observable o = Observable.never();
+
+        assertSame(o, (((HasUpstreamObservableSource)o.publish()).source()));
+    }
+
+    @Test
+    public void connectThrows() {
+        ConnectableObservable co = Observable.empty().publish();
+        try {
+            co.connect(new Consumer() {
+                @Override
+                public void accept(Disposable d) throws Exception {
+                    throw new TestException();
+                }
+            });
+        } catch (TestException ex) {
+            // expected
+        }
+    }
+
+    @Test
+    public void addRemoveRace() {
+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+
+            final ConnectableObservable co = Observable.empty().publish();
+
+            final TestObserver to = co.test();
+
+            final TestObserver to2 = new TestObserver();
+
+            Runnable r1 = new Runnable() {
+                @Override
+                public void run() {
+                    co.subscribe(to2);
+                }
+            };
+
+            Runnable r2 = new Runnable() {
+                @Override
+                public void run() {
+                    to.cancel();
+                }
+            };
+
+            TestHelper.race(r1, r2);
+        }
+    }
+
+    @Test
+    public void disposeOnArrival() {
+        ConnectableObservable co = Observable.empty().publish();
+
+        co.test(true).assertEmpty();
+    }
+
+    @Test
+    public void dispose() {
+        TestHelper.checkDisposed(Observable.never().publish());
+
+        TestHelper.checkDisposed(Observable.never().publish(Functions.>identity()));
+    }
+
+    @Test
+    public void empty() {
+        ConnectableObservable co = Observable.empty().publish();
+
+        co.connect();
+    }
+
+    @Test
+    public void take() {
+        ConnectableObservable co = Observable.range(1, 2).publish();
+
+        TestObserver to = co.take(1).test();
+
+        co.connect();
+
+        to.assertResult(1);
+    }
+
+    @Test
+    public void just() {
+        final PublishSubject ps = PublishSubject.create();
+
+        ConnectableObservable co = ps.publish();
+
+        TestObserver to = new TestObserver() {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                ps.onComplete();
+            }
+        };
+
+        co.subscribe(to);
+        co.connect();
+
+        ps.onNext(1);
+
+        to.assertResult(1);
+    }
+
+    @Test
+    public void nextCancelRace() {
+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+
+            final PublishSubject ps = PublishSubject.create();
+
+            final ConnectableObservable co = ps.publish();
+
+            final TestObserver to = co.test();
+
+            Runnable r1 = new Runnable() {
+                @Override
+                public void run() {
+                    ps.onNext(1);
+                }
+            };
+
+            Runnable r2 = new Runnable() {
+                @Override
+                public void run() {
+                    to.cancel();
+                }
+            };
+
+            TestHelper.race(r1, r2);
+        }
+    }
+
+    @Test
+    public void badSource() {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            new Observable() {
+                @Override
+                protected void subscribeActual(Observer observer) {
+                    observer.onSubscribe(Disposables.empty());
+                    observer.onNext(1);
+                    observer.onComplete();
+                    observer.onNext(2);
+                    observer.onError(new TestException());
+                    observer.onComplete();
+                }
+            }
+            .publish()
+            .autoConnect()
+            .test()
+            .assertResult(1);
+
+            TestHelper.assertUndeliverable(errors, 0, TestException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    @Test
+    public void noErrorLoss() {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            ConnectableObservable co = Observable.error(new TestException()).publish();
+
+            co.connect();
+
+            TestHelper.assertUndeliverable(errors, 0, TestException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    @Test
+    public void subscribeDisconnectRace() {
+        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+
+            final PublishSubject ps = PublishSubject.create();
+
+            final ConnectableObservable co = ps.publish();
+
+            final Disposable d = co.connect();
+            final TestObserver to = new TestObserver();
+
+            Runnable r1 = new Runnable() {
+                @Override
+                public void run() {
+                    d.dispose();
+                }
+            };
+
+            Runnable r2 = new Runnable() {
+                @Override
+                public void run() {
+                    co.subscribe(to);
+                }
+            };
+
+            TestHelper.race(r1, r2);
+        }
+    }
+
+    @Test
+    public void selectorDisconnectsIndependentSource() {
+        PublishSubject ps = PublishSubject.create();
+
+        ps.publish(new Function, ObservableSource>() {
+            @Override
+            public ObservableSource apply(Observable v) throws Exception {
+                return Observable.range(1, 2);
+            }
+        })
+        .test()
+        .assertResult(1, 2);
+
+        assertFalse(ps.hasObservers());
+    }
+
+    @Test(timeout = 5000)
+    public void selectorLatecommer() {
+        Observable.range(1, 5)
+        .publish(new Function, ObservableSource>() {
+            @Override
+            public ObservableSource apply(Observable v) throws Exception {
+                return v.concatWith(v);
+            }
+        })
+        .test()
+        .assertResult(1, 2, 3, 4, 5);
+    }
+
+    @Test
+    public void mainError() {
+        Observable.error(new TestException())
+        .publish(Functions.>identity())
+        .test()
+        .assertFailure(TestException.class);
+    }
+
+    @Test
+    public void selectorInnerError() {
+        PublishSubject ps = PublishSubject.create();
+
+        ps.publish(new Function, ObservableSource>() {
+            @Override
+            public ObservableSource apply(Observable v) throws Exception {
+                return Observable.error(new TestException());
+            }
+        })
+        .test()
+        .assertFailure(TestException.class);
+
+        assertFalse(ps.hasObservers());
+    }
+
+    @Test
+    public void delayedUpstreamOnSubscribe() {
+        final Observer[] sub = { null };
+
+        new Observable() {
+            @Override
+            protected void subscribeActual(Observer observer) {
+                sub[0] = observer;
+            }
+        }
+        .publish()
+        .connect()
+        .dispose();
+
+        Disposable bs = Disposables.empty();
+
+        sub[0].onSubscribe(bs);
+
+        assertTrue(bs.isDisposed());
+    }
+
+    @Test
+    public void doubleOnSubscribe() {
+        TestHelper.checkDoubleOnSubscribeObservable(new Function, ObservableSource>() {
+            @Override
+            public ObservableSource apply(final Observable o)
+                    throws Exception {
+                return Observable.never().publish(new Function, ObservableSource>() {
+                    @Override
+                    public ObservableSource apply(Observable v)
+                            throws Exception {
+                        return o;
+                    }
+                });
+            }
+        }
+        );
+    }
+
+    @Test
+    public void disposedUpfront() {
+        ConnectableObservable co = Observable.just(1)
+                .concatWith(Observable.never())
+                .publish();
+
+        TestObserver to1 = co.test();
+
+        TestObserver to2 = co.test(true);
+
+        co.connect();
+
+        to1.assertValuesOnly(1);
+
+        to2.assertEmpty();
+
+        ((ObservablePublish)co).current.get().remove(null);
+    }
+
+    @Test
+    public void altConnectCrash() {
+        try {
+            new ObservablePublishAlt(Observable.empty())
+            .connect(new Consumer() {
+                @Override
+                public void accept(Disposable t) throws Exception {
+                    throw new TestException();
+                }
+            });
+            fail("Should have thrown");
+        } catch (TestException expected) {
+            // expected
+        }
+    }
+
+    @Test
+    public void altConnectRace() {
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            final ConnectableObservable co =
+                    new ObservablePublishAlt(Observable.never());
+
+            Runnable r = new Runnable() {
+                @Override
+                public void run() {
+                    co.connect();
+                }
+            };
+
+            TestHelper.race(r, r);
+        }
+    }
+}
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservablePublishTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservablePublishTest.java
index 2f2a0e677e..7534f07346 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservablePublishTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservablePublishTest.java
@@ -19,7 +19,7 @@
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 
-import org.junit.Test;
+import org.junit.*;
 
 import io.reactivex.*;
 import io.reactivex.Observable;
@@ -37,6 +37,27 @@
 
 public class ObservablePublishTest {
 
+    // This will undo the workaround so that the plain ObservablePublish is still
+    // tested.
+    @Before
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public void before() {
+        RxJavaPlugins.setOnConnectableObservableAssembly(new Function() {
+            @Override
+            public ConnectableObservable apply(ConnectableObservable co) throws Exception {
+                if (co instanceof ObservablePublishAlt) {
+                    return ObservablePublish.create(((ObservablePublishAlt)co).source());
+                }
+                return co;
+            }
+        });
+    }
+
+    @After
+    public void after() {
+        RxJavaPlugins.setOnConnectableObservableAssembly(null);
+    }
+
     @Test
     public void testPublish() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableRangeLongTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableRangeLongTest.java
index d09ec0d6ce..dfe1713902 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableRangeLongTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableRangeLongTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.ArrayList;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableRangeTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableRangeTest.java
index cbdc0130ec..d54847c0b2 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableRangeTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableRangeTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.ArrayList;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableReduceTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableReduceTest.java
index cb6e61e8f6..c1c7ffbeb6 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableReduceTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableReduceTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableRefCountAltTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableRefCountAltTest.java
new file mode 100644
index 0000000000..0f675bd15d
--- /dev/null
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableRefCountAltTest.java
@@ -0,0 +1,1421 @@
+/**
+ * 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.internal.operators.observable;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import java.io.IOException;
+import java.lang.management.ManagementFactory;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+
+import io.reactivex.*;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.*;
+import io.reactivex.exceptions.*;
+import io.reactivex.functions.*;
+import io.reactivex.internal.functions.Functions;
+import io.reactivex.internal.operators.observable.ObservableRefCount.RefConnection;
+import io.reactivex.internal.util.ExceptionHelper;
+import io.reactivex.observables.ConnectableObservable;
+import io.reactivex.observers.TestObserver;
+import io.reactivex.plugins.RxJavaPlugins;
+import io.reactivex.schedulers.*;
+import io.reactivex.subjects.*;
+
+public class ObservableRefCountAltTest {
+
+    @Test
+    public void testRefCountAsync() {
+        final AtomicInteger subscribeCount = new AtomicInteger();
+        final AtomicInteger nextCount = new AtomicInteger();
+        Observable r = Observable.interval(0, 25, TimeUnit.MILLISECONDS)
+                .doOnSubscribe(new Consumer() {
+                    @Override
+                    public void accept(Disposable d) {
+                        subscribeCount.incrementAndGet();
+                    }
+                })
+                .doOnNext(new Consumer() {
+                    @Override
+                    public void accept(Long l) {
+                        nextCount.incrementAndGet();
+                    }
+                })
+                .publish().refCount();
+
+        final AtomicInteger receivedCount = new AtomicInteger();
+        Disposable d1 = r.subscribe(new Consumer() {
+            @Override
+            public void accept(Long l) {
+                receivedCount.incrementAndGet();
+            }
+        });
+
+        Disposable d2 = r.subscribe();
+
+        // give time to emit
+        try {
+            Thread.sleep(260);
+        } catch (InterruptedException e) {
+        }
+
+        // now unsubscribe
+        d2.dispose(); // unsubscribe s2 first as we're counting in 1 and there can be a race between unsubscribe and one Observer getting a value but not the other
+        d1.dispose();
+
+        System.out.println("onNext: " + nextCount.get());
+
+        // should emit once for both subscribers
+        assertEquals(nextCount.get(), receivedCount.get());
+        // only 1 subscribe
+        assertEquals(1, subscribeCount.get());
+    }
+
+    @Test
+    public void testRefCountSynchronous() {
+        final AtomicInteger subscribeCount = new AtomicInteger();
+        final AtomicInteger nextCount = new AtomicInteger();
+        Observable r = Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9)
+                .doOnSubscribe(new Consumer() {
+                    @Override
+                    public void accept(Disposable d) {
+                        subscribeCount.incrementAndGet();
+                    }
+                })
+                .doOnNext(new Consumer() {
+                    @Override
+                    public void accept(Integer l) {
+                        nextCount.incrementAndGet();
+                    }
+                })
+                .publish().refCount();
+
+        final AtomicInteger receivedCount = new AtomicInteger();
+        Disposable d1 = r.subscribe(new Consumer() {
+            @Override
+            public void accept(Integer l) {
+                receivedCount.incrementAndGet();
+            }
+        });
+
+        Disposable d2 = r.subscribe();
+
+        // give time to emit
+        try {
+            Thread.sleep(50);
+        } catch (InterruptedException e) {
+        }
+
+        // now unsubscribe
+        d2.dispose(); // unsubscribe s2 first as we're counting in 1 and there can be a race between unsubscribe and one Observer getting a value but not the other
+        d1.dispose();
+
+        System.out.println("onNext Count: " + nextCount.get());
+
+        // it will emit twice because it is synchronous
+        assertEquals(nextCount.get(), receivedCount.get() * 2);
+        // it will subscribe twice because it is synchronous
+        assertEquals(2, subscribeCount.get());
+    }
+
+    @Test
+    public void testRefCountSynchronousTake() {
+        final AtomicInteger nextCount = new AtomicInteger();
+        Observable r = Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9)
+                .doOnNext(new Consumer() {
+                    @Override
+                    public void accept(Integer l) {
+                            System.out.println("onNext --------> " + l);
+                            nextCount.incrementAndGet();
+                    }
+                })
+                .take(4)
+                .publish().refCount();
+
+        final AtomicInteger receivedCount = new AtomicInteger();
+        r.subscribe(new Consumer() {
+            @Override
+            public void accept(Integer l) {
+                receivedCount.incrementAndGet();
+            }
+        });
+
+        System.out.println("onNext: " + nextCount.get());
+
+        assertEquals(4, receivedCount.get());
+        assertEquals(4, receivedCount.get());
+    }
+
+    @Test
+    public void testRepeat() {
+        final AtomicInteger subscribeCount = new AtomicInteger();
+        final AtomicInteger unsubscribeCount = new AtomicInteger();
+        Observable r = Observable.interval(0, 1, TimeUnit.MILLISECONDS)
+                .doOnSubscribe(new Consumer() {
+                    @Override
+                    public void accept(Disposable d) {
+                            System.out.println("******************************* Subscribe received");
+                            // when we are subscribed
+                            subscribeCount.incrementAndGet();
+                    }
+                })
+                .doOnDispose(new Action() {
+                    @Override
+                    public void run() {
+                            System.out.println("******************************* Unsubscribe received");
+                            // when we are unsubscribed
+                            unsubscribeCount.incrementAndGet();
+                    }
+                })
+                .publish().refCount();
+
+        for (int i = 0; i < 10; i++) {
+            TestObserver to1 = new TestObserver();
+            TestObserver to2 = new TestObserver();
+            r.subscribe(to1);
+            r.subscribe(to2);
+            try {
+                Thread.sleep(50);
+            } catch (InterruptedException e) {
+            }
+            to1.dispose();
+            to2.dispose();
+            to1.assertNoErrors();
+            to2.assertNoErrors();
+            assertTrue(to1.valueCount() > 0);
+            assertTrue(to2.valueCount() > 0);
+        }
+
+        assertEquals(10, subscribeCount.get());
+        assertEquals(10, unsubscribeCount.get());
+    }
+
+    @Test
+    public void testConnectUnsubscribe() throws InterruptedException {
+        final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
+        final CountDownLatch subscribeLatch = new CountDownLatch(1);
+
+        Observable o = synchronousInterval()
+                .doOnSubscribe(new Consumer() {
+                    @Override
+                    public void accept(Disposable d) {
+                            System.out.println("******************************* Subscribe received");
+                            // when we are subscribed
+                            subscribeLatch.countDown();
+                    }
+                })
+                .doOnDispose(new Action() {
+                    @Override
+                    public void run() {
+                            System.out.println("******************************* Unsubscribe received");
+                            // when we are unsubscribed
+                            unsubscribeLatch.countDown();
+                    }
+                });
+
+        TestObserver observer = new TestObserver();
+        o.publish().refCount().subscribeOn(Schedulers.newThread()).subscribe(observer);
+        System.out.println("send unsubscribe");
+        // wait until connected
+        subscribeLatch.await();
+        // now unsubscribe
+        observer.dispose();
+        System.out.println("DONE sending unsubscribe ... now waiting");
+        if (!unsubscribeLatch.await(3000, TimeUnit.MILLISECONDS)) {
+            System.out.println("Errors: " + observer.errors());
+            if (observer.errors().size() > 0) {
+                observer.errors().get(0).printStackTrace();
+            }
+            fail("timed out waiting for unsubscribe");
+        }
+        observer.assertNoErrors();
+    }
+
+    @Test
+    public void testConnectUnsubscribeRaceConditionLoop() throws InterruptedException {
+        for (int i = 0; i < 100; i++) {
+            testConnectUnsubscribeRaceCondition();
+        }
+    }
+
+    @Test
+    public void testConnectUnsubscribeRaceCondition() throws InterruptedException {
+        final AtomicInteger subUnsubCount = new AtomicInteger();
+        Observable o = synchronousInterval()
+                .doOnDispose(new Action() {
+                    @Override
+                    public void run() {
+                            System.out.println("******************************* Unsubscribe received");
+                            // when we are unsubscribed
+                            subUnsubCount.decrementAndGet();
+                    }
+                })
+                .doOnSubscribe(new Consumer() {
+                    @Override
+                    public void accept(Disposable d) {
+                            System.out.println("******************************* SUBSCRIBE received");
+                            subUnsubCount.incrementAndGet();
+                    }
+                });
+
+        TestObserver observer = new TestObserver();
+
+        o.publish().refCount().subscribeOn(Schedulers.computation()).subscribe(observer);
+        System.out.println("send unsubscribe");
+        // now immediately unsubscribe while subscribeOn is racing to subscribe
+        observer.dispose();
+
+        // this generally will mean it won't even subscribe as it is already unsubscribed by the time connect() gets scheduled
+        // give time to the counter to update
+        Thread.sleep(10);
+
+        // make sure we wait a bit in case the counter is still nonzero
+        int counter = 200;
+        while (subUnsubCount.get() != 0 && counter-- != 0) {
+            Thread.sleep(10);
+        }
+        // either we subscribed and then unsubscribed, or we didn't ever even subscribe
+        assertEquals(0, subUnsubCount.get());
+
+        System.out.println("DONE sending unsubscribe ... now waiting");
+        System.out.println("Errors: " + observer.errors());
+        if (observer.errors().size() > 0) {
+            observer.errors().get(0).printStackTrace();
+        }
+        observer.assertNoErrors();
+    }
+
+    private Observable synchronousInterval() {
+        return Observable.unsafeCreate(new ObservableSource() {
+            @Override
+            public void subscribe(Observer observer) {
+                final AtomicBoolean cancel = new AtomicBoolean();
+                observer.onSubscribe(Disposables.fromRunnable(new Runnable() {
+                    @Override
+                    public void run() {
+                        cancel.set(true);
+                    }
+                }));
+                for (;;) {
+                    if (cancel.get()) {
+                        break;
+                    }
+                    try {
+                        Thread.sleep(100);
+                    } catch (InterruptedException e) {
+                    }
+                    observer.onNext(1L);
+                }
+            }
+        });
+    }
+
+    @Test
+    public void onlyFirstShouldSubscribeAndLastUnsubscribe() {
+        final AtomicInteger subscriptionCount = new AtomicInteger();
+        final AtomicInteger unsubscriptionCount = new AtomicInteger();
+        Observable o = Observable.unsafeCreate(new ObservableSource() {
+            @Override
+            public void subscribe(Observer observer) {
+                subscriptionCount.incrementAndGet();
+                observer.onSubscribe(Disposables.fromRunnable(new Runnable() {
+                    @Override
+                    public void run() {
+                            unsubscriptionCount.incrementAndGet();
+                    }
+                }));
+            }
+        });
+        Observable refCounted = o.publish().refCount();
+
+        Disposable first = refCounted.subscribe();
+        assertEquals(1, subscriptionCount.get());
+
+        Disposable second = refCounted.subscribe();
+        assertEquals(1, subscriptionCount.get());
+
+        first.dispose();
+        assertEquals(0, unsubscriptionCount.get());
+
+        second.dispose();
+        assertEquals(1, unsubscriptionCount.get());
+    }
+
+    @Test
+    public void testRefCount() {
+        TestScheduler s = new TestScheduler();
+        Observable interval = Observable.interval(100, TimeUnit.MILLISECONDS, s).publish().refCount();
+
+        // subscribe list1
+        final List list1 = new ArrayList();
+        Disposable d1 = interval.subscribe(new Consumer() {
+            @Override
+            public void accept(Long t1) {
+                list1.add(t1);
+            }
+        });
+
+        s.advanceTimeBy(200, TimeUnit.MILLISECONDS);
+
+        assertEquals(2, list1.size());
+        assertEquals(0L, list1.get(0).longValue());
+        assertEquals(1L, list1.get(1).longValue());
+
+        // subscribe list2
+        final List list2 = new ArrayList();
+        Disposable d2 = interval.subscribe(new Consumer() {
+            @Override
+            public void accept(Long t1) {
+                list2.add(t1);
+            }
+        });
+
+        s.advanceTimeBy(300, TimeUnit.MILLISECONDS);
+
+        // list 1 should have 5 items
+        assertEquals(5, list1.size());
+        assertEquals(2L, list1.get(2).longValue());
+        assertEquals(3L, list1.get(3).longValue());
+        assertEquals(4L, list1.get(4).longValue());
+
+        // list 2 should only have 3 items
+        assertEquals(3, list2.size());
+        assertEquals(2L, list2.get(0).longValue());
+        assertEquals(3L, list2.get(1).longValue());
+        assertEquals(4L, list2.get(2).longValue());
+
+        // unsubscribe list1
+        d1.dispose();
+
+        // advance further
+        s.advanceTimeBy(300, TimeUnit.MILLISECONDS);
+
+        // list 1 should still have 5 items
+        assertEquals(5, list1.size());
+
+        // list 2 should have 6 items
+        assertEquals(6, list2.size());
+        assertEquals(5L, list2.get(3).longValue());
+        assertEquals(6L, list2.get(4).longValue());
+        assertEquals(7L, list2.get(5).longValue());
+
+        // unsubscribe list2
+        d2.dispose();
+
+        // advance further
+        s.advanceTimeBy(1000, TimeUnit.MILLISECONDS);
+
+        // subscribing a new one should start over because the source should have been unsubscribed
+        // subscribe list3
+        final List list3 = new ArrayList();
+        interval.subscribe(new Consumer() {
+            @Override
+            public void accept(Long t1) {
+                list3.add(t1);
+            }
+        });
+
+        s.advanceTimeBy(200, TimeUnit.MILLISECONDS);
+
+        assertEquals(2, list3.size());
+        assertEquals(0L, list3.get(0).longValue());
+        assertEquals(1L, list3.get(1).longValue());
+
+    }
+
+    @Test
+    public void testAlreadyUnsubscribedClient() {
+        Observer done = DisposingObserver.INSTANCE;
+
+        Observer o = TestHelper.mockObserver();
+
+        Observable result = Observable.just(1).publish().refCount();
+
+        result.subscribe(done);
+
+        result.subscribe(o);
+
+        verify(o).onNext(1);
+        verify(o).onComplete();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+
+    @Test
+    public void testAlreadyUnsubscribedInterleavesWithClient() {
+        ReplaySubject source = ReplaySubject.create();
+
+        Observer done = DisposingObserver.INSTANCE;
+
+        Observer o = TestHelper.mockObserver();
+        InOrder inOrder = inOrder(o);
+
+        Observable result = source.publish().refCount();
+
+        result.subscribe(o);
+
+        source.onNext(1);
+
+        result.subscribe(done);
+
+        source.onNext(2);
+        source.onComplete();
+
+        inOrder.verify(o).onNext(1);
+        inOrder.verify(o).onNext(2);
+        inOrder.verify(o).onComplete();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+
+    @Test
+    public void testConnectDisconnectConnectAndSubjectState() {
+        Observable o1 = Observable.just(10);
+        Observable o2 = Observable.just(20);
+        Observable combined = Observable.combineLatest(o1, o2, new BiFunction() {
+            @Override
+            public Integer apply(Integer t1, Integer t2) {
+                return t1 + t2;
+            }
+        })
+        .publish().refCount();
+
+        TestObserver to1 = new TestObserver();
+        TestObserver to2 = new TestObserver();
+
+        combined.subscribe(to1);
+        combined.subscribe(to2);
+
+        to1.assertTerminated();
+        to1.assertNoErrors();
+        to1.assertValue(30);
+
+        to2.assertTerminated();
+        to2.assertNoErrors();
+        to2.assertValue(30);
+    }
+
+    @Test(timeout = 10000)
+    public void testUpstreamErrorAllowsRetry() throws InterruptedException {
+        final AtomicInteger intervalSubscribed = new AtomicInteger();
+        Observable interval =
+                Observable.interval(200, TimeUnit.MILLISECONDS)
+                        .doOnSubscribe(new Consumer() {
+                            @Override
+                            public void accept(Disposable d) {
+                                            System.out.println("Subscribing to interval " + intervalSubscribed.incrementAndGet());
+                                    }
+                        }
+                         )
+                        .flatMap(new Function>() {
+                            @Override
+                            public Observable apply(Long t1) {
+                                    return Observable.defer(new Callable>() {
+                                        @Override
+                                        public Observable call() {
+                                                return Observable.error(new Exception("Some exception"));
+                                        }
+                                    });
+                            }
+                        })
+                        .onErrorResumeNext(new Function>() {
+                            @Override
+                            public Observable apply(Throwable t1) {
+                                    return Observable.error(t1);
+                            }
+                        })
+                        .publish()
+                        .refCount();
+
+        interval
+                .doOnError(new Consumer() {
+                    @Override
+                    public void accept(Throwable t1) {
+                            System.out.println("Observer 1 onError: " + t1);
+                    }
+                })
+                .retry(5)
+                .subscribe(new Consumer() {
+                    @Override
+                    public void accept(String t1) {
+                            System.out.println("Observer 1: " + t1);
+                    }
+                });
+        Thread.sleep(100);
+        interval
+        .doOnError(new Consumer() {
+            @Override
+            public void accept(Throwable t1) {
+                    System.out.println("Observer 2 onError: " + t1);
+            }
+        })
+        .retry(5)
+                .subscribe(new Consumer() {
+                    @Override
+                    public void accept(String t1) {
+                            System.out.println("Observer 2: " + t1);
+                    }
+                });
+
+        Thread.sleep(1300);
+
+        System.out.println(intervalSubscribed.get());
+        assertEquals(6, intervalSubscribed.get());
+    }
+
+    private enum DisposingObserver implements Observer {
+        INSTANCE;
+
+        @Override
+        public void onSubscribe(Disposable d) {
+            d.dispose();
+        }
+
+        @Override
+        public void onNext(Integer t) {
+        }
+
+        @Override
+        public void onError(Throwable t) {
+        }
+
+        @Override
+        public void onComplete() {
+        }
+    }
+
+    @Test
+    public void disposed() {
+        TestHelper.checkDisposed(Observable.just(1).publish().refCount());
+    }
+
+    @Test
+    public void noOpConnect() {
+        final int[] calls = { 0 };
+        Observable o = new ConnectableObservable() {
+            @Override
+            public void connect(Consumer connection) {
+                calls[0]++;
+            }
+
+            @Override
+            protected void subscribeActual(Observer observer) {
+                observer.onSubscribe(Disposables.disposed());
+            }
+        }.refCount();
+
+        o.test();
+        o.test();
+
+        assertEquals(1, calls[0]);
+    }
+    Observable source;
+
+    @Test
+    public void replayNoLeak() throws Exception {
+        System.gc();
+        Thread.sleep(250);
+
+        long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = Observable.fromCallable(new Callable() {
+            @Override
+            public Object call() throws Exception {
+                return new byte[100 * 1000 * 1000];
+            }
+        })
+        .replay(1)
+        .refCount();
+
+        source.subscribe();
+
+        System.gc();
+        Thread.sleep(250);
+
+        long after = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = null;
+        assertTrue(String.format("%,3d -> %,3d%n", start, after), start + 20 * 1000 * 1000 > after);
+    }
+
+    @Test
+    public void replayNoLeak2() throws Exception {
+        System.gc();
+        Thread.sleep(250);
+
+        long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = Observable.fromCallable(new Callable() {
+            @Override
+            public Object call() throws Exception {
+                return new byte[100 * 1000 * 1000];
+            }
+        }).concatWith(Observable.never())
+        .replay(1)
+        .refCount();
+
+        Disposable d1 = source.subscribe();
+        Disposable d2 = source.subscribe();
+
+        d1.dispose();
+        d2.dispose();
+
+        d1 = null;
+        d2 = null;
+
+        System.gc();
+        Thread.sleep(250);
+
+        long after = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = null;
+        assertTrue(String.format("%,3d -> %,3d%n", start, after), start + 20 * 1000 * 1000 > after);
+    }
+
+    static final class ExceptionData extends Exception {
+        private static final long serialVersionUID = -6763898015338136119L;
+
+        public final Object data;
+
+        ExceptionData(Object data) {
+            this.data = data;
+        }
+    }
+
+    @Test
+    public void publishNoLeak() throws Exception {
+        System.gc();
+        Thread.sleep(250);
+
+        long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = Observable.fromCallable(new Callable() {
+            @Override
+            public Object call() throws Exception {
+                throw new ExceptionData(new byte[100 * 1000 * 1000]);
+            }
+        })
+        .publish()
+        .refCount();
+
+        source.subscribe(Functions.emptyConsumer(), Functions.emptyConsumer());
+
+        long after = 0L;
+
+        for (int i = 0; i < 10; i++) {
+            System.gc();
+
+            after = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+            if (start + 20 * 1000 * 1000 > after) {
+                break;
+            }
+
+            Thread.sleep(100);
+        }
+
+        source = null;
+        assertTrue(String.format("%,3d -> %,3d%n", start, after), start + 20 * 1000 * 1000 > after);
+    }
+
+    @Test
+    public void publishNoLeak2() throws Exception {
+        System.gc();
+        Thread.sleep(250);
+
+        long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = Observable.fromCallable(new Callable() {
+            @Override
+            public Object call() throws Exception {
+                return new byte[100 * 1000 * 1000];
+            }
+        }).concatWith(Observable.never())
+        .publish()
+        .refCount();
+
+        Disposable d1 = source.test();
+        Disposable d2 = source.test();
+
+        d1.dispose();
+        d2.dispose();
+
+        d1 = null;
+        d2 = null;
+
+        System.gc();
+        Thread.sleep(250);
+
+        long after = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = null;
+        assertTrue(String.format("%,3d -> %,3d%n", start, after), start + 20 * 1000 * 1000 > after);
+    }
+
+    @Test
+    public void replayIsUnsubscribed() {
+        ConnectableObservable co = Observable.just(1).concatWith(Observable.never())
+        .replay();
+
+        if (co instanceof Disposable) {
+            assertTrue(((Disposable)co).isDisposed());
+
+            Disposable connection = co.connect();
+
+            assertFalse(((Disposable)co).isDisposed());
+
+            connection.dispose();
+
+            assertTrue(((Disposable)co).isDisposed());
+        }
+    }
+
+    static final class BadObservableSubscribe extends ConnectableObservable {
+
+        @Override
+        public void connect(Consumer connection) {
+            try {
+                connection.accept(Disposables.empty());
+            } catch (Throwable ex) {
+                throw ExceptionHelper.wrapOrThrow(ex);
+            }
+        }
+
+        @Override
+        protected void subscribeActual(Observer observer) {
+            throw new TestException("subscribeActual");
+        }
+    }
+
+    static final class BadObservableDispose extends ConnectableObservable implements Disposable {
+
+        @Override
+        public void dispose() {
+            throw new TestException("dispose");
+        }
+
+        @Override
+        public boolean isDisposed() {
+            return false;
+        }
+
+        @Override
+        public void connect(Consumer connection) {
+            try {
+                connection.accept(Disposables.empty());
+            } catch (Throwable ex) {
+                throw ExceptionHelper.wrapOrThrow(ex);
+            }
+        }
+
+        @Override
+        protected void subscribeActual(Observer observer) {
+            observer.onSubscribe(Disposables.empty());
+        }
+    }
+
+    static final class BadObservableConnect extends ConnectableObservable {
+
+        @Override
+        public void connect(Consumer connection) {
+            throw new TestException("connect");
+        }
+
+        @Override
+        protected void subscribeActual(Observer observer) {
+            observer.onSubscribe(Disposables.empty());
+        }
+    }
+
+    @Test
+    public void badSourceSubscribe() {
+        BadObservableSubscribe bo = new BadObservableSubscribe();
+
+        try {
+            bo.refCount()
+            .test();
+            fail("Should have thrown");
+        } catch (NullPointerException ex) {
+            assertTrue(ex.getCause() instanceof TestException);
+        }
+    }
+
+    @Test
+    public void badSourceDispose() {
+        BadObservableDispose bo = new BadObservableDispose();
+
+        try {
+            bo.refCount()
+            .test()
+            .cancel();
+            fail("Should have thrown");
+        } catch (TestException expected) {
+        }
+    }
+
+    @Test
+    public void badSourceConnect() {
+        BadObservableConnect bo = new BadObservableConnect();
+
+        try {
+            bo.refCount()
+            .test();
+            fail("Should have thrown");
+        } catch (NullPointerException ex) {
+            assertTrue(ex.getCause() instanceof TestException);
+        }
+    }
+
+    static final class BadObservableSubscribe2 extends ConnectableObservable {
+
+        int count;
+
+        @Override
+        public void connect(Consumer connection) {
+            try {
+                connection.accept(Disposables.empty());
+            } catch (Throwable ex) {
+                throw ExceptionHelper.wrapOrThrow(ex);
+            }
+        }
+
+        @Override
+        protected void subscribeActual(Observer observer) {
+            if (++count == 1) {
+                observer.onSubscribe(Disposables.empty());
+            } else {
+                throw new TestException("subscribeActual");
+            }
+        }
+    }
+
+    @Test
+    public void badSourceSubscribe2() {
+        BadObservableSubscribe2 bo = new BadObservableSubscribe2();
+
+        Observable o = bo.refCount();
+        o.test();
+        try {
+            o.test();
+            fail("Should have thrown");
+        } catch (NullPointerException ex) {
+            assertTrue(ex.getCause() instanceof TestException);
+        }
+    }
+
+    static final class BadObservableConnect2 extends ConnectableObservable
+    implements Disposable {
+
+        @Override
+        public void connect(Consumer connection) {
+            try {
+                connection.accept(Disposables.empty());
+            } catch (Throwable ex) {
+                throw ExceptionHelper.wrapOrThrow(ex);
+            }
+        }
+
+        @Override
+        protected void subscribeActual(Observer observer) {
+            observer.onSubscribe(Disposables.empty());
+            observer.onComplete();
+        }
+
+        @Override
+        public void dispose() {
+            throw new TestException("dispose");
+        }
+
+        @Override
+        public boolean isDisposed() {
+            return false;
+        }
+    }
+
+    @Test
+    public void badSourceCompleteDisconnect() {
+        BadObservableConnect2 bo = new BadObservableConnect2();
+
+        try {
+            bo.refCount()
+            .test();
+            fail("Should have thrown");
+        } catch (NullPointerException ex) {
+            assertTrue(ex.getCause() instanceof TestException);
+        }
+    }
+
+    @Test(timeout = 7500)
+    public void blockingSourceAsnycCancel() throws Exception {
+        BehaviorSubject bs = BehaviorSubject.createDefault(1);
+
+        Observable o = bs
+        .replay(1)
+        .refCount();
+
+        o.subscribe();
+
+        final AtomicBoolean interrupted = new AtomicBoolean();
+
+        o.switchMap(new Function>() {
+            @Override
+            public ObservableSource apply(Integer v) throws Exception {
+                return Observable.create(new ObservableOnSubscribe() {
+                    @Override
+                    public void subscribe(ObservableEmitter emitter) throws Exception {
+                        while (!emitter.isDisposed()) {
+                            Thread.sleep(100);
+                        }
+                        interrupted.set(true);
+                    }
+                });
+            }
+        })
+        .take(500, TimeUnit.MILLISECONDS)
+        .test()
+        .awaitDone(5, TimeUnit.SECONDS)
+        .assertResult();
+
+        assertTrue(interrupted.get());
+    }
+
+    @Test
+    public void byCount() {
+        final int[] subscriptions = { 0 };
+
+        Observable source = Observable.range(1, 5)
+        .doOnSubscribe(new Consumer() {
+            @Override
+            public void accept(Disposable d) throws Exception {
+                subscriptions[0]++;
+            }
+        })
+        .publish()
+        .refCount(2);
+
+        for (int i = 0; i < 3; i++) {
+            TestObserver to1 = source.test();
+
+            to1.withTag("to1 " + i);
+            to1.assertEmpty();
+
+            TestObserver to2 = source.test();
+
+            to2.withTag("to2 " + i);
+
+            to1.assertResult(1, 2, 3, 4, 5);
+            to2.assertResult(1, 2, 3, 4, 5);
+        }
+
+        assertEquals(3, subscriptions[0]);
+    }
+
+    @Test
+    public void resubscribeBeforeTimeout() throws Exception {
+        final int[] subscriptions = { 0 };
+
+        PublishSubject ps = PublishSubject.create();
+
+        Observable source = ps
+        .doOnSubscribe(new Consumer() {
+            @Override
+            public void accept(Disposable d) throws Exception {
+                subscriptions[0]++;
+            }
+        })
+        .publish()
+        .refCount(500, TimeUnit.MILLISECONDS);
+
+        TestObserver to1 = source.test();
+
+        assertEquals(1, subscriptions[0]);
+
+        to1.cancel();
+
+        Thread.sleep(100);
+
+        to1 = source.test();
+
+        assertEquals(1, subscriptions[0]);
+
+        Thread.sleep(500);
+
+        assertEquals(1, subscriptions[0]);
+
+        ps.onNext(1);
+        ps.onNext(2);
+        ps.onNext(3);
+        ps.onNext(4);
+        ps.onNext(5);
+        ps.onComplete();
+
+        to1
+        .assertResult(1, 2, 3, 4, 5);
+    }
+
+    @Test
+    public void letitTimeout() throws Exception {
+        final int[] subscriptions = { 0 };
+
+        PublishSubject ps = PublishSubject.create();
+
+        Observable source = ps
+        .doOnSubscribe(new Consumer() {
+            @Override
+            public void accept(Disposable d) throws Exception {
+                subscriptions[0]++;
+            }
+        })
+        .publish()
+        .refCount(1, 100, TimeUnit.MILLISECONDS);
+
+        TestObserver to1 = source.test();
+
+        assertEquals(1, subscriptions[0]);
+
+        to1.cancel();
+
+        assertTrue(ps.hasObservers());
+
+        Thread.sleep(200);
+
+        assertFalse(ps.hasObservers());
+    }
+
+    @Test
+    public void error() {
+        Observable.error(new IOException())
+        .publish()
+        .refCount(500, TimeUnit.MILLISECONDS)
+        .test()
+        .assertFailure(IOException.class);
+    }
+
+    @Test
+    public void comeAndGo() {
+        PublishSubject ps = PublishSubject.create();
+
+        Observable source = ps
+        .publish()
+        .refCount(1);
+
+        TestObserver to1 = source.test();
+
+        assertTrue(ps.hasObservers());
+
+        for (int i = 0; i < 3; i++) {
+            TestObserver to2 = source.test();
+            to1.cancel();
+            to1 = to2;
+        }
+
+        to1.cancel();
+
+        assertFalse(ps.hasObservers());
+    }
+
+    @Test
+    public void unsubscribeSubscribeRace() {
+        for (int i = 0; i < 1000; i++) {
+
+            final Observable source = Observable.range(1, 5)
+                    .replay()
+                    .refCount(1)
+                    ;
+
+            final TestObserver to1 = source.test();
+
+            final TestObserver to2 = new TestObserver();
+
+            Runnable r1 = new Runnable() {
+                @Override
+                public void run() {
+                    to1.cancel();
+                }
+            };
+
+            Runnable r2 = new Runnable() {
+                @Override
+                public void run() {
+                    source.subscribe(to2);
+                }
+            };
+
+            TestHelper.race(r1, r2, Schedulers.single());
+
+            to2
+            .withTag("Round: " + i)
+            .assertResult(1, 2, 3, 4, 5);
+        }
+    }
+
+    static final class BadObservableDoubleOnX extends ConnectableObservable
+    implements Disposable {
+
+        @Override
+        public void connect(Consumer connection) {
+            try {
+                connection.accept(Disposables.empty());
+            } catch (Throwable ex) {
+                throw ExceptionHelper.wrapOrThrow(ex);
+            }
+        }
+
+        @Override
+        protected void subscribeActual(Observer observer) {
+            observer.onSubscribe(Disposables.empty());
+            observer.onSubscribe(Disposables.empty());
+            observer.onComplete();
+            observer.onComplete();
+            observer.onError(new TestException());
+        }
+
+        @Override
+        public void dispose() {
+        }
+
+        @Override
+        public boolean isDisposed() {
+            return false;
+        }
+    }
+
+    @Test
+    public void doubleOnX() {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            new BadObservableDoubleOnX()
+            .refCount()
+            .test()
+            .assertResult();
+
+            TestHelper.assertError(errors, 0, ProtocolViolationException.class);
+            TestHelper.assertUndeliverable(errors, 1, TestException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    @Test
+    public void doubleOnXCount() {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            new BadObservableDoubleOnX()
+            .refCount(1)
+            .test()
+            .assertResult();
+
+            TestHelper.assertError(errors, 0, ProtocolViolationException.class);
+            TestHelper.assertUndeliverable(errors, 1, TestException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    @Test
+    public void doubleOnXTime() {
+        List errors = TestHelper.trackPluginErrors();
+        try {
+            new BadObservableDoubleOnX()
+            .refCount(5, TimeUnit.SECONDS, Schedulers.single())
+            .test()
+            .assertResult();
+
+            TestHelper.assertError(errors, 0, ProtocolViolationException.class);
+            TestHelper.assertUndeliverable(errors, 1, TestException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    @Test
+    public void cancelTerminateStateExclusion() {
+        ObservableRefCount o = (ObservableRefCount)PublishSubject.create()
+        .publish()
+        .refCount();
+
+        o.cancel(null);
+
+        o.cancel(new RefConnection(o));
+
+        RefConnection rc = new RefConnection(o);
+        o.connection = null;
+        rc.subscriberCount = 0;
+        o.timeout(rc);
+
+        rc.subscriberCount = 1;
+        o.timeout(rc);
+
+        o.connection = rc;
+        o.timeout(rc);
+
+        rc.subscriberCount = 0;
+        o.timeout(rc);
+
+        // -------------------
+
+        rc.subscriberCount = 2;
+        rc.connected = false;
+        o.connection = rc;
+        o.cancel(rc);
+
+        rc.subscriberCount = 1;
+        rc.connected = false;
+        o.connection = rc;
+        o.cancel(rc);
+
+        rc.subscriberCount = 2;
+        rc.connected = true;
+        o.connection = rc;
+        o.cancel(rc);
+
+        rc.subscriberCount = 1;
+        rc.connected = true;
+        o.connection = rc;
+        rc.lazySet(null);
+        o.cancel(rc);
+
+        o.connection = rc;
+        o.cancel(new RefConnection(o));
+    }
+
+    @Test
+    public void replayRefCountShallBeThreadSafe() {
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            Observable observable = Observable.just(1).replay(1).refCount();
+
+            TestObserver observer1 = observable
+                    .subscribeOn(Schedulers.io())
+                    .test();
+
+            TestObserver observer2 = observable
+                    .subscribeOn(Schedulers.io())
+                    .test();
+
+            observer1
+            .withTag("" + i)
+            .awaitDone(5, TimeUnit.SECONDS)
+            .assertResult(1);
+
+            observer2
+            .withTag("" + i)
+            .awaitDone(5, TimeUnit.SECONDS)
+            .assertResult(1);
+        }
+    }
+
+    static final class TestConnectableObservable extends ConnectableObservable
+    implements Disposable {
+
+        volatile boolean disposed;
+
+        @Override
+        public void dispose() {
+            disposed = true;
+        }
+
+        @Override
+        public boolean isDisposed() {
+            return disposed;
+        }
+
+        @Override
+        public void connect(Consumer connection) {
+            // not relevant
+        }
+
+        @Override
+        protected void subscribeActual(Observer observer) {
+            // not relevant
+        }
+    }
+
+    @Test
+    public void timeoutDisposesSource() {
+        ObservableRefCount o = (ObservableRefCount)new TestConnectableObservable().refCount();
+
+        RefConnection rc = new RefConnection(o);
+        o.connection = rc;
+
+        o.timeout(rc);
+
+        assertTrue(((Disposable)o.source).isDisposed());
+    }
+
+    @Test
+    public void disconnectBeforeConnect() {
+        BehaviorSubject subject = BehaviorSubject.create();
+
+        Observable observable = subject
+                .replay(1)
+                .refCount();
+
+        observable.takeUntil(Observable.just(1)).test();
+
+        subject.onNext(2);
+
+        observable.take(1).test().assertResult(2);
+    }
+
+    @Test
+    public void publishRefCountShallBeThreadSafe() {
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            Observable observable = Observable.just(1).publish().refCount();
+
+            TestObserver observer1 = observable
+                    .subscribeOn(Schedulers.io())
+                    .test();
+
+            TestObserver observer2 = observable
+                    .subscribeOn(Schedulers.io())
+                    .test();
+
+            observer1
+            .withTag("observer1 " + i)
+            .awaitDone(5, TimeUnit.SECONDS)
+            .assertNoErrors()
+            .assertComplete();
+
+            observer2
+            .withTag("observer2 " + i)
+            .awaitDone(5, TimeUnit.SECONDS)
+            .assertNoErrors()
+            .assertComplete();
+        }
+    }
+
+    @Test
+    public void upstreamTerminationTriggersAnotherCancel() throws Exception {
+        ReplaySubject rs = ReplaySubject.create();
+        rs.onNext(1);
+        rs.onComplete();
+
+        Observable shared = rs.share();
+
+        shared
+        .buffer(shared.debounce(5, TimeUnit.SECONDS))
+        .test()
+        .assertValueCount(2);
+
+        shared
+        .buffer(shared.debounce(5, TimeUnit.SECONDS))
+        .test()
+        .assertValueCount(2);
+    }
+}
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableRefCountTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableRefCountTest.java
index 0f0d930d8d..485afc54e1 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableRefCountTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableRefCountTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
@@ -23,7 +22,7 @@
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 
-import org.junit.Test;
+import org.junit.*;
 import org.mockito.InOrder;
 
 import io.reactivex.*;
@@ -43,6 +42,27 @@
 
 public class ObservableRefCountTest {
 
+    // This will undo the workaround so that the plain ObservablePublish is still
+    // tested.
+    @Before
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public void before() {
+        RxJavaPlugins.setOnConnectableObservableAssembly(new Function() {
+            @Override
+            public ConnectableObservable apply(ConnectableObservable co) throws Exception {
+                if (co instanceof ObservablePublishAlt) {
+                    return ObservablePublish.create(((ObservablePublishAlt)co).source());
+                }
+                return co;
+            }
+        });
+    }
+
+    @After
+    public void after() {
+        RxJavaPlugins.setOnConnectableObservableAssembly(null);
+    }
+
     @Test
     public void testRefCountAsync() {
         final AtomicInteger subscribeCount = new AtomicInteger();
@@ -631,7 +651,7 @@ protected void subscribeActual(Observer observer) {
     @Test
     public void replayNoLeak() throws Exception {
         System.gc();
-        Thread.sleep(100);
+        Thread.sleep(250);
 
         long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
 
@@ -647,7 +667,7 @@ public Object call() throws Exception {
         source.subscribe();
 
         System.gc();
-        Thread.sleep(100);
+        Thread.sleep(250);
 
         long after = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
 
@@ -658,7 +678,7 @@ public Object call() throws Exception {
     @Test
     public void replayNoLeak2() throws Exception {
         System.gc();
-        Thread.sleep(100);
+        Thread.sleep(250);
 
         long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
 
@@ -681,7 +701,7 @@ public Object call() throws Exception {
         d2 = null;
 
         System.gc();
-        Thread.sleep(100);
+        Thread.sleep(250);
 
         long after = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
 
@@ -702,7 +722,7 @@ static final class ExceptionData extends Exception {
     @Test
     public void publishNoLeak() throws Exception {
         System.gc();
-        Thread.sleep(100);
+        Thread.sleep(250);
 
         long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
 
@@ -718,7 +738,7 @@ public Object call() throws Exception {
         source.subscribe(Functions.emptyConsumer(), Functions.emptyConsumer());
 
         System.gc();
-        Thread.sleep(100);
+        Thread.sleep(250);
 
         long after = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
 
@@ -729,7 +749,7 @@ public Object call() throws Exception {
     @Test
     public void publishNoLeak2() throws Exception {
         System.gc();
-        Thread.sleep(100);
+        Thread.sleep(250);
 
         long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
 
@@ -752,7 +772,7 @@ public Object call() throws Exception {
         d2 = null;
 
         System.gc();
-        Thread.sleep(100);
+        Thread.sleep(250);
 
         long after = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
 
@@ -1360,4 +1380,23 @@ public void disconnectBeforeConnect() {
 
         observable.take(1).test().assertResult(2);
     }
+
+    @Test
+    public void upstreamTerminationTriggersAnotherCancel() throws Exception {
+        ReplaySubject rs = ReplaySubject.create();
+        rs.onNext(1);
+        rs.onComplete();
+
+        Observable shared = rs.share();
+
+        shared
+        .buffer(shared.debounce(5, TimeUnit.SECONDS))
+        .test()
+        .assertValueCount(2);
+
+        shared
+        .buffer(shared.debounce(5, TimeUnit.SECONDS))
+        .test()
+        .assertValueCount(2);
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableRepeatTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableRepeatTest.java
index 3afc1f1cc7..538b4a0c69 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableRepeatTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableRepeatTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
@@ -30,6 +29,7 @@
 import io.reactivex.exceptions.TestException;
 import io.reactivex.functions.*;
 import io.reactivex.observers.TestObserver;
+import io.reactivex.plugins.RxJavaPlugins;
 import io.reactivex.schedulers.Schedulers;
 import io.reactivex.subjects.PublishSubject;
 
@@ -397,4 +397,56 @@ public boolean test(Object v) throws Exception {
 
         assertEquals(0, counter.get());
     }
+
+    @Test
+    public void repeatFloodNoSubscriptionError() {
+        List errors = TestHelper.trackPluginErrors();
+
+        try {
+            final PublishSubject source = PublishSubject.create();
+            final PublishSubject signaller = PublishSubject.create();
+
+            for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+
+                TestObserver to = source.take(1)
+                .repeatWhen(new Function, ObservableSource>() {
+                    @Override
+                    public ObservableSource apply(Observable v)
+                            throws Exception {
+                        return signaller;
+                    }
+                }).test();
+
+                Runnable r1 = new Runnable() {
+                    @Override
+                    public void run() {
+                        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+                            source.onNext(1);
+                        }
+                    }
+                };
+                Runnable r2 = new Runnable() {
+                    @Override
+                    public void run() {
+                        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+                            signaller.onNext(1);
+                        }
+                    }
+                };
+
+                TestHelper.race(r1, r2);
+
+                to.dispose();
+            }
+
+            if (!errors.isEmpty()) {
+                for (Throwable e : errors) {
+                    e.printStackTrace();
+                }
+                fail(errors + "");
+            }
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableReplayTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableReplayTest.java
index 2592361cd6..7c768f36cc 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableReplayTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableReplayTest.java
@@ -14,12 +14,12 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
+import java.lang.management.*;
 import java.util.*;
 import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.*;
 
 import org.junit.*;
 import org.mockito.InOrder;
@@ -1713,4 +1713,66 @@ public void noHeadRetentionTime() {
 
         assertSame(o, buf.get());
     }
-}
+
+    @Test
+    public void noBoundedRetentionViaThreadLocal() throws Exception {
+        Observable source = Observable.range(1, 200)
+        .map(new Function() {
+            @Override
+            public byte[] apply(Integer v) throws Exception {
+                return new byte[1024 * 1024];
+            }
+        })
+        .replay(new Function, Observable>() {
+            @Override
+            public Observable apply(final Observable o) throws Exception {
+                return o.take(1)
+                .concatMap(new Function>() {
+                    @Override
+                    public Observable apply(byte[] v) throws Exception {
+                        return o;
+                    }
+                });
+            }
+        }, 1)
+        .takeLast(1)
+        ;
+
+        System.out.println("Bounded Replay Leak check: Wait before GC");
+        Thread.sleep(1000);
+
+        System.out.println("Bounded Replay Leak check: GC");
+        System.gc();
+
+        Thread.sleep(500);
+
+        final MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
+        MemoryUsage memHeap = memoryMXBean.getHeapMemoryUsage();
+        long initial = memHeap.getUsed();
+
+        System.out.printf("Bounded Replay Leak check: Starting: %.3f MB%n", initial / 1024.0 / 1024.0);
+
+        final AtomicLong after = new AtomicLong();
+
+        source.subscribe(new Consumer() {
+            @Override
+            public void accept(byte[] v) throws Exception {
+                System.out.println("Bounded Replay Leak check: Wait before GC 2");
+                Thread.sleep(1000);
+
+                System.out.println("Bounded Replay Leak check:  GC 2");
+                System.gc();
+
+                Thread.sleep(500);
+
+                after.set(memoryMXBean.getHeapMemoryUsage().getUsed());
+            }
+        });
+
+        System.out.printf("Bounded Replay Leak check: After: %.3f MB%n", after.get() / 1024.0 / 1024.0);
+
+        if (initial + 100 * 1024 * 1024 < after.get()) {
+            Assert.fail("Bounded Replay Leak check: Memory leak detected: " + (initial / 1024.0 / 1024.0)
+                    + " -> " + after.get() / 1024.0 / 1024.0);
+        }
+    }}
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableRetryTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableRetryTest.java
index e576479921..ab7998c8a1 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableRetryTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableRetryTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
@@ -34,6 +33,7 @@
 import io.reactivex.internal.subscriptions.BooleanSubscription;
 import io.reactivex.observables.GroupedObservable;
 import io.reactivex.observers.*;
+import io.reactivex.plugins.RxJavaPlugins;
 import io.reactivex.schedulers.Schedulers;
 import io.reactivex.subjects.PublishSubject;
 
@@ -1131,4 +1131,64 @@ public boolean test(Object v) throws Exception {
 
         assertEquals(0, counter.get());
     }
+
+    @Test
+    public void repeatFloodNoSubscriptionError() {
+        List errors = TestHelper.trackPluginErrors();
+
+        final TestException error = new TestException();
+
+        try {
+            final PublishSubject source = PublishSubject.create();
+            final PublishSubject signaller = PublishSubject.create();
+
+            for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+
+                TestObserver to = source.take(1)
+                .map(new Function() {
+                    @Override
+                    public Integer apply(Integer v) throws Exception {
+                        throw error;
+                    }
+                })
+                .retryWhen(new Function, ObservableSource>() {
+                    @Override
+                    public ObservableSource apply(Observable v)
+                            throws Exception {
+                        return signaller;
+                    }
+                }).test();
+
+                Runnable r1 = new Runnable() {
+                    @Override
+                    public void run() {
+                        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+                            source.onNext(1);
+                        }
+                    }
+                };
+                Runnable r2 = new Runnable() {
+                    @Override
+                    public void run() {
+                        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
+                            signaller.onNext(1);
+                        }
+                    }
+                };
+
+                TestHelper.race(r1, r2);
+
+                to.dispose();
+            }
+
+            if (!errors.isEmpty()) {
+                for (Throwable e : errors) {
+                    e.printStackTrace();
+                }
+                fail(errors + "");
+            }
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableRetryWithPredicateTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableRetryWithPredicateTest.java
index 7b0322ab87..debeb8eec4 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableRetryWithPredicateTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableRetryWithPredicateTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableSampleTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableSampleTest.java
index 01f04653f2..7e3098216c 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableSampleTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableSampleTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.observable;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.concurrent.TimeUnit;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableScanTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableScanTest.java
index 35df1a462e..e078f92505 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableScanTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableScanTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableSequenceEqualTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableSequenceEqualTest.java
index 4a7a33ddd6..da996cfc22 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableSequenceEqualTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableSequenceEqualTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.observable;
 
-import static org.mockito.ArgumentMatchers.isA;
 import static org.mockito.Mockito.*;
 
 import org.junit.*;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableSkipLastTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableSkipLastTest.java
index b89d70b8df..c97f851700 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableSkipLastTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableSkipLastTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.Arrays;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableSkipLastTimedTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableSkipLastTimedTest.java
index 50df641a26..3cf4d2e155 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableSkipLastTimedTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableSkipLastTimedTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.observable;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.concurrent.TimeUnit;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableSkipWhileTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableSkipWhileTest.java
index d4772b1a6a..9e809b88cc 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableSkipWhileTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableSkipWhileTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.observable;
 
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import org.junit.Test;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableSwitchTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableSwitchTest.java
index 610f49eac4..83b5a51270 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableSwitchTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableSwitchTest.java
@@ -17,7 +17,7 @@
 import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
-import java.util.List;
+import java.util.*;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.*;
 
@@ -25,16 +25,18 @@
 import org.mockito.InOrder;
 
 import io.reactivex.*;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
 import io.reactivex.disposables.*;
 import io.reactivex.exceptions.*;
 import io.reactivex.functions.*;
 import io.reactivex.internal.functions.Functions;
 import io.reactivex.internal.schedulers.ImmediateThinScheduler;
 import io.reactivex.internal.util.ExceptionHelper;
-import io.reactivex.observers.TestObserver;
+import io.reactivex.observers.*;
 import io.reactivex.plugins.RxJavaPlugins;
 import io.reactivex.schedulers.*;
-import io.reactivex.subjects.*;
+import io.reactivex.subjects.PublishSubject;
 
 public class ObservableSwitchTest {
 
@@ -1192,4 +1194,102 @@ public Object apply(Integer w) throws Exception {
         .assertNoErrors()
         .assertComplete();
     }
+
+    @Test
+    public void switchMapFusedIterable() {
+        Observable.range(1, 2)
+        .switchMap(new Function>() {
+            @Override
+            public Observable apply(Integer v)
+                    throws Exception {
+                return Observable.fromIterable(Arrays.asList(v * 10));
+            }
+        })
+        .test()
+        .assertResult(10, 20);
+    }
+
+    @Test
+    public void switchMapHiddenIterable() {
+        Observable.range(1, 2)
+        .switchMap(new Function>() {
+            @Override
+            public Observable apply(Integer v)
+                    throws Exception {
+                return Observable.fromIterable(Arrays.asList(v * 10)).hide();
+            }
+        })
+        .test()
+        .assertResult(10, 20);
+    }
+
+    @Test
+    public void cancellationShouldTriggerInnerCancellationRace() throws Throwable {
+        final AtomicInteger outer = new AtomicInteger();
+        final AtomicInteger inner = new AtomicInteger();
+
+        int n = 10000;
+        for (int i = 0; i < n; i++) {
+            Observable.create(new ObservableOnSubscribe() {
+                @Override
+                public void subscribe(ObservableEmitter it)
+                        throws Exception {
+                            it.onNext(0);
+                        }
+            })
+            .switchMap(new Function>() {
+                @Override
+                public ObservableSource apply(Integer v)
+                        throws Exception {
+                    return createObservable(inner);
+                }
+            })
+            .observeOn(Schedulers.computation())
+            .doFinally(new Action() {
+                @Override
+                public void run() throws Exception {
+                    outer.incrementAndGet();
+                }
+            })
+            .take(1)
+            .blockingSubscribe(Functions.emptyConsumer(), new Consumer() {
+                @Override
+                public void accept(Throwable e) throws Exception {
+                    e.printStackTrace();
+                }
+            });
+        }
+
+        Thread.sleep(100);
+        assertEquals(inner.get(), outer.get());
+        assertEquals(n, inner.get());
+    }
+
+    Observable createObservable(final AtomicInteger inner) {
+        return Observable.unsafeCreate(new ObservableSource() {
+            @Override
+            public void subscribe(Observer observer) {
+                final SerializedObserver it = new SerializedObserver(observer);
+                it.onSubscribe(Disposables.empty());
+                Schedulers.io().scheduleDirect(new Runnable() {
+                    @Override
+                    public void run() {
+                        it.onNext(1);
+                    }
+                }, 0, TimeUnit.MILLISECONDS);
+                Schedulers.io().scheduleDirect(new Runnable() {
+                    @Override
+                    public void run() {
+                        it.onNext(2);
+                    }
+                }, 0, TimeUnit.MILLISECONDS);
+            }
+        })
+        .doFinally(new Action() {
+            @Override
+            public void run() throws Exception {
+                inner.incrementAndGet();
+            }
+        });
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableTakeLastTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableTakeLastTest.java
index 34ab87312b..1eb89adc6a 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableTakeLastTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableTakeLastTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.concurrent.atomic.AtomicInteger;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableTakeLastTimedTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableTakeLastTimedTest.java
index bc933f9b02..2aa3f38c7e 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableTakeLastTimedTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableTakeLastTimedTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.observable;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.concurrent.TimeUnit;
@@ -276,4 +275,27 @@ public void run() {
             TestHelper.race(r1, r2);
         }
     }
+
+    @Test
+    public void lastWindowIsFixedInTime() {
+        TimesteppingScheduler scheduler = new TimesteppingScheduler();
+        scheduler.stepEnabled = false;
+
+        PublishSubject ps = PublishSubject.create();
+
+        TestObserver to = ps
+        .takeLast(2, TimeUnit.SECONDS, scheduler)
+        .test();
+
+        ps.onNext(1);
+        ps.onNext(2);
+        ps.onNext(3);
+        ps.onNext(4);
+
+        scheduler.stepEnabled = true;
+
+        ps.onComplete();
+
+        to.assertResult(1, 2, 3, 4);
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableTakeTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableTakeTest.java
index a9b9ae35d9..341409f958 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableTakeTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableTakeTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableTakeUntilPredicateTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableTakeUntilPredicateTest.java
index 0e6f040972..9fa6c21bca 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableTakeUntilPredicateTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableTakeUntilPredicateTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.observable;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableTimeoutTests.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableTimeoutTests.java
index 935922b67c..9d517ec1be 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableTimeoutTests.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableTimeoutTests.java
@@ -15,7 +15,6 @@
 
 import static io.reactivex.internal.util.ExceptionHelper.timeoutMessage;
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableTimeoutWithSelectorTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableTimeoutWithSelectorTest.java
index 3dad40f34a..a0d8a93ebe 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableTimeoutWithSelectorTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableTimeoutWithSelectorTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableTimerTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableTimerTest.java
index c8af9d88b8..124283dc1f 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableTimerTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableTimerTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableToListTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableToListTest.java
index 18447143aa..1f28cfc5d2 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableToListTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableToListTest.java
@@ -13,7 +13,6 @@
 
 package io.reactivex.internal.operators.observable;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableUnsubscribeOnTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableUnsubscribeOnTest.java
index 2b7d7f4141..1067ff37c9 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableUnsubscribeOnTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableUnsubscribeOnTest.java
@@ -72,7 +72,7 @@ public void subscribe(Observer t1) {
 
             System.out.println("unsubscribeThread: " + unsubscribeThread);
             System.out.println("subscribeThread.get(): " + subscribeThread.get());
-            assertTrue(unsubscribeThread.toString(), unsubscribeThread == uiEventLoop.getThread());
+            assertSame(unsubscribeThread.toString(), unsubscribeThread, uiEventLoop.getThread());
 
             observer.assertValues(1, 2);
             observer.assertTerminated();
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableWindowWithObservableTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableWindowWithObservableTest.java
index a82e876464..9f8969222b 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableWindowWithObservableTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableWindowWithObservableTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableWindowWithStartEndObservableTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableWindowWithStartEndObservableTest.java
index d1426a5a61..c4f7fa6409 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableWindowWithStartEndObservableTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableWindowWithStartEndObservableTest.java
@@ -17,6 +17,7 @@
 
 import java.util.*;
 import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.*;
 
@@ -256,8 +257,8 @@ public Observable apply(Integer t) {
 
         to.dispose();
 
-        // FIXME subject has subscribers because of the open window
-        assertTrue(open.hasObservers());
+        // Disposing the outer sequence stops the opening of new windows
+        assertFalse(open.hasObservers());
         // FIXME subject has subscribers because of the open window
         assertTrue(close.hasObservers());
     }
@@ -423,4 +424,38 @@ protected void subscribeActual(
             RxJavaPlugins.reset();
         }
     }
+
+    static Observable observableDisposed(final AtomicBoolean ref) {
+        return Observable.just(1).concatWith(Observable.never())
+                .doOnDispose(new Action() {
+                    @Override
+                    public void run() throws Exception {
+                        ref.set(true);
+                    }
+                });
+    }
+
+    @Test
+    public void mainAndBoundaryDisposeOnNoWindows() {
+        AtomicBoolean mainDisposed = new AtomicBoolean();
+        AtomicBoolean openDisposed = new AtomicBoolean();
+        final AtomicBoolean closeDisposed = new AtomicBoolean();
+
+        observableDisposed(mainDisposed)
+        .window(observableDisposed(openDisposed), new Function>() {
+            @Override
+            public ObservableSource apply(Integer v) throws Exception {
+                return observableDisposed(closeDisposed);
+            }
+        })
+        .test()
+        .assertSubscribed()
+        .assertNoErrors()
+        .assertNotComplete()
+        .dispose();
+
+        assertTrue(mainDisposed.get());
+        assertTrue(openDisposed.get());
+        assertTrue(closeDisposed.get());
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableWindowWithTimeTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableWindowWithTimeTest.java
index 4eb90f4e50..8500d52948 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableWindowWithTimeTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableWindowWithTimeTest.java
@@ -16,8 +16,8 @@
 import static org.junit.Assert.*;
 
 import java.util.*;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
 
 import org.junit.*;
 
@@ -64,17 +64,19 @@ public void subscribe(Observer observer) {
         Observable> windowed = source.window(100, TimeUnit.MILLISECONDS, scheduler, 2);
         windowed.subscribe(observeWindow(list, lists));
 
-        scheduler.advanceTimeTo(100, TimeUnit.MILLISECONDS);
+        scheduler.advanceTimeTo(95, TimeUnit.MILLISECONDS);
         assertEquals(1, lists.size());
         assertEquals(lists.get(0), list("one", "two"));
 
-        scheduler.advanceTimeTo(200, TimeUnit.MILLISECONDS);
-        assertEquals(2, lists.size());
-        assertEquals(lists.get(1), list("three", "four"));
+        scheduler.advanceTimeTo(195, TimeUnit.MILLISECONDS);
+        assertEquals(3, lists.size());
+        assertTrue(lists.get(1).isEmpty());
+        assertEquals(lists.get(2), list("three", "four"));
 
         scheduler.advanceTimeTo(300, TimeUnit.MILLISECONDS);
-        assertEquals(3, lists.size());
-        assertEquals(lists.get(2), list("five"));
+        assertEquals(5, lists.size());
+        assertTrue(lists.get(3).isEmpty());
+        assertEquals(lists.get(4), list("five"));
     }
 
     @Test
@@ -706,4 +708,244 @@ public void countRestartsOnTimeTick() {
         .assertNoErrors()
         .assertNotComplete();
     }
+
+    @Test
+    public void exactTimeBoundNoInterruptWindowOutputOnComplete() throws Exception {
+        final AtomicBoolean isInterrupted = new AtomicBoolean();
+
+        final PublishSubject ps = PublishSubject.create();
+
+        final CountDownLatch doOnNextDone = new CountDownLatch(1);
+        final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
+
+        ps.window(100, TimeUnit.MILLISECONDS)
+        .doOnNext(new Consumer>() {
+            int count;
+            @Override
+            public void accept(Observable v) throws Exception {
+                System.out.println(Thread.currentThread());
+                if (count++ == 1) {
+                    secondWindowProcessing.countDown();
+                    try {
+                        Thread.sleep(200);
+                        isInterrupted.set(Thread.interrupted());
+                    } catch (InterruptedException ex) {
+                        isInterrupted.set(true);
+                    }
+                    doOnNextDone.countDown();
+                }
+            }
+        })
+        .test();
+
+        ps.onNext(1);
+
+        assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
+
+        ps.onComplete();
+
+        assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
+
+        assertFalse("The doOnNext got interrupted!", isInterrupted.get());
+    }
+
+    @Test
+    public void exactTimeBoundNoInterruptWindowOutputOnError() throws Exception {
+        final AtomicBoolean isInterrupted = new AtomicBoolean();
+
+        final PublishSubject ps = PublishSubject.create();
+
+        final CountDownLatch doOnNextDone = new CountDownLatch(1);
+        final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
+
+        ps.window(100, TimeUnit.MILLISECONDS)
+        .doOnNext(new Consumer>() {
+            int count;
+            @Override
+            public void accept(Observable v) throws Exception {
+                System.out.println(Thread.currentThread());
+                if (count++ == 1) {
+                    secondWindowProcessing.countDown();
+                    try {
+                        Thread.sleep(200);
+                        isInterrupted.set(Thread.interrupted());
+                    } catch (InterruptedException ex) {
+                        isInterrupted.set(true);
+                    }
+                    doOnNextDone.countDown();
+                }
+            }
+        })
+        .test();
+
+        ps.onNext(1);
+
+        assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
+
+        ps.onError(new TestException());
+
+        assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
+
+        assertFalse("The doOnNext got interrupted!", isInterrupted.get());
+    }
+
+    @Test
+    public void exactTimeAndSizeBoundNoInterruptWindowOutputOnComplete() throws Exception {
+        final AtomicBoolean isInterrupted = new AtomicBoolean();
+
+        final PublishSubject ps = PublishSubject.create();
+
+        final CountDownLatch doOnNextDone = new CountDownLatch(1);
+        final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
+
+        ps.window(100, TimeUnit.MILLISECONDS, 10)
+        .doOnNext(new Consumer>() {
+            int count;
+            @Override
+            public void accept(Observable v) throws Exception {
+                System.out.println(Thread.currentThread());
+                if (count++ == 1) {
+                    secondWindowProcessing.countDown();
+                    try {
+                        Thread.sleep(200);
+                        isInterrupted.set(Thread.interrupted());
+                    } catch (InterruptedException ex) {
+                        isInterrupted.set(true);
+                    }
+                    doOnNextDone.countDown();
+                }
+            }
+        })
+        .test();
+
+        ps.onNext(1);
+
+        assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
+
+        ps.onComplete();
+
+        assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
+
+        assertFalse("The doOnNext got interrupted!", isInterrupted.get());
+    }
+
+    @Test
+    public void exactTimeAndSizeBoundNoInterruptWindowOutputOnError() throws Exception {
+        final AtomicBoolean isInterrupted = new AtomicBoolean();
+
+        final PublishSubject ps = PublishSubject.create();
+
+        final CountDownLatch doOnNextDone = new CountDownLatch(1);
+        final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
+
+        ps.window(100, TimeUnit.MILLISECONDS, 10)
+        .doOnNext(new Consumer>() {
+            int count;
+            @Override
+            public void accept(Observable v) throws Exception {
+                System.out.println(Thread.currentThread());
+                if (count++ == 1) {
+                    secondWindowProcessing.countDown();
+                    try {
+                        Thread.sleep(200);
+                        isInterrupted.set(Thread.interrupted());
+                    } catch (InterruptedException ex) {
+                        isInterrupted.set(true);
+                    }
+                    doOnNextDone.countDown();
+                }
+            }
+        })
+        .test();
+
+        ps.onNext(1);
+
+        assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
+
+        ps.onError(new TestException());
+
+        assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
+
+        assertFalse("The doOnNext got interrupted!", isInterrupted.get());
+    }
+
+    @Test
+    public void skipTimeAndSizeBoundNoInterruptWindowOutputOnComplete() throws Exception {
+        final AtomicBoolean isInterrupted = new AtomicBoolean();
+
+        final PublishSubject ps = PublishSubject.create();
+
+        final CountDownLatch doOnNextDone = new CountDownLatch(1);
+        final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
+
+        ps.window(90, 100, TimeUnit.MILLISECONDS)
+        .doOnNext(new Consumer>() {
+            int count;
+            @Override
+            public void accept(Observable v) throws Exception {
+                System.out.println(Thread.currentThread());
+                if (count++ == 1) {
+                    secondWindowProcessing.countDown();
+                    try {
+                        Thread.sleep(200);
+                        isInterrupted.set(Thread.interrupted());
+                    } catch (InterruptedException ex) {
+                        isInterrupted.set(true);
+                    }
+                    doOnNextDone.countDown();
+                }
+            }
+        })
+        .test();
+
+        ps.onNext(1);
+
+        assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
+
+        ps.onComplete();
+
+        assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
+
+        assertFalse("The doOnNext got interrupted!", isInterrupted.get());
+    }
+
+    @Test
+    public void skipTimeAndSizeBoundNoInterruptWindowOutputOnError() throws Exception {
+        final AtomicBoolean isInterrupted = new AtomicBoolean();
+
+        final PublishSubject ps = PublishSubject.create();
+
+        final CountDownLatch doOnNextDone = new CountDownLatch(1);
+        final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
+
+        ps.window(90, 100, TimeUnit.MILLISECONDS)
+        .doOnNext(new Consumer>() {
+            int count;
+            @Override
+            public void accept(Observable v) throws Exception {
+                System.out.println(Thread.currentThread());
+                if (count++ == 1) {
+                    secondWindowProcessing.countDown();
+                    try {
+                        Thread.sleep(200);
+                        isInterrupted.set(Thread.interrupted());
+                    } catch (InterruptedException ex) {
+                        isInterrupted.set(true);
+                    }
+                    doOnNextDone.countDown();
+                }
+            }
+        })
+        .test();
+
+        ps.onNext(1);
+
+        assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
+
+        ps.onError(new TestException());
+
+        assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
+
+        assertFalse("The doOnNext got interrupted!", isInterrupted.get());
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableZipIterableTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableZipIterableTest.java
index 971359d8ad..f05c41cfd3 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableZipIterableTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableZipIterableTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableZipTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableZipTest.java
index 2fc7d7cb52..eca18c71b3 100644
--- a/src/test/java/io/reactivex/internal/operators/observable/ObservableZipTest.java
+++ b/src/test/java/io/reactivex/internal/operators/observable/ObservableZipTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.internal.operators.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
@@ -1351,6 +1350,34 @@ public Object apply(Object[] a) throws Exception {
         .assertResult("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]");
     }
 
+    /**
+     * Ensures that an ObservableSource implementation can be supplied that doesn't subclass Observable
+     */
+    @Test
+    public void zipIterableNotSubclassingObservable() {
+        final ObservableSource s1 = new ObservableSource() {
+            @Override
+            public void subscribe (final Observer observer) {
+                Observable.just(1).subscribe(observer);
+            }
+        };
+        final ObservableSource s2 = new ObservableSource() {
+            @Override
+            public void subscribe (final Observer observer) {
+                Observable.just(2).subscribe(observer);
+            }
+        };
+
+        Observable.zip(Arrays.asList(s1, s2), new Function() {
+            @Override
+            public Object apply(Object[] a) throws Exception {
+                return Arrays.toString(a);
+            }
+        })
+        .test()
+        .assertResult("[1, 2]");
+    }
+
     @Test
     public void dispose() {
         TestHelper.checkDisposed(Observable.zip(Observable.just(1), Observable.just(1), new BiFunction() {
@@ -1428,4 +1455,35 @@ public Integer apply(Integer t1, Integer t2) throws Exception {
         ps2.onNext(2);
         to.assertResult(3);
     }
+
+    @Test
+    public void firstErrorPreventsSecondSubscription() {
+        final AtomicInteger counter = new AtomicInteger();
+
+        List> observableList = new ArrayList>();
+        observableList.add(Observable.create(new ObservableOnSubscribe() {
+            @Override
+            public void subscribe(ObservableEmitter e)
+                    throws Exception { throw new TestException(); }
+        }));
+        observableList.add(Observable.create(new ObservableOnSubscribe() {
+            @Override
+            public void subscribe(ObservableEmitter e)
+                    throws Exception { counter.getAndIncrement(); }
+        }));
+
+        Observable.zip(observableList,
+                new Function() {
+                    @Override
+                    public Object apply(Object[] a) throws Exception {
+                        return a;
+                    }
+                })
+        .test()
+        .assertFailure(TestException.class)
+        ;
+
+        assertEquals(0, counter.get());
+    }
+
 }
diff --git a/src/test/java/io/reactivex/internal/operators/single/SingleAmbTest.java b/src/test/java/io/reactivex/internal/operators/single/SingleAmbTest.java
index 1bc00dedd6..18f4f3be65 100644
--- a/src/test/java/io/reactivex/internal/operators/single/SingleAmbTest.java
+++ b/src/test/java/io/reactivex/internal/operators/single/SingleAmbTest.java
@@ -16,14 +16,18 @@
 import static org.junit.Assert.*;
 
 import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.Test;
 
 import io.reactivex.*;
 import io.reactivex.exceptions.TestException;
+import io.reactivex.functions.BiConsumer;
 import io.reactivex.observers.TestObserver;
 import io.reactivex.plugins.RxJavaPlugins;
 import io.reactivex.processors.PublishProcessor;
+import io.reactivex.schedulers.Schedulers;
 import io.reactivex.subjects.*;
 
 public class SingleAmbTest {
@@ -280,4 +284,61 @@ public void ambArrayOrder() {
         Single error = Single.error(new RuntimeException());
         Single.ambArray(Single.just(1), error).test().assertValue(1);
     }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void noWinnerSuccessDispose() throws Exception {
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            final AtomicBoolean interrupted = new AtomicBoolean();
+            final CountDownLatch cdl = new CountDownLatch(1);
+
+            Single.ambArray(
+                Single.just(1)
+                    .subscribeOn(Schedulers.single())
+                    .observeOn(Schedulers.computation()),
+                Single.never()
+            )
+            .subscribe(new BiConsumer() {
+                @Override
+                public void accept(Object v, Throwable e) throws Exception {
+                    assertNotNull(v);
+                    assertNull(e);
+                    interrupted.set(Thread.currentThread().isInterrupted());
+                    cdl.countDown();
+                }
+            });
+
+            assertTrue(cdl.await(500, TimeUnit.SECONDS));
+            assertFalse("Interrupted!", interrupted.get());
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void noWinnerErrorDispose() throws Exception {
+        final TestException ex = new TestException();
+        for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
+            final AtomicBoolean interrupted = new AtomicBoolean();
+            final CountDownLatch cdl = new CountDownLatch(1);
+
+            Single.ambArray(
+                Single.error(ex)
+                    .subscribeOn(Schedulers.single())
+                    .observeOn(Schedulers.computation()),
+                Single.never()
+            )
+            .subscribe(new BiConsumer() {
+                @Override
+                public void accept(Object v, Throwable e) throws Exception {
+                    assertNull(v);
+                    assertNotNull(e);
+                    interrupted.set(Thread.currentThread().isInterrupted());
+                    cdl.countDown();
+                }
+            });
+
+            assertTrue(cdl.await(500, TimeUnit.SECONDS));
+            assertFalse("Interrupted!", interrupted.get());
+        }
+    }
 }
diff --git a/src/test/java/io/reactivex/internal/operators/single/SingleDoOnTerminateTest.java b/src/test/java/io/reactivex/internal/operators/single/SingleDoOnTerminateTest.java
new file mode 100644
index 0000000000..425ee84205
--- /dev/null
+++ b/src/test/java/io/reactivex/internal/operators/single/SingleDoOnTerminateTest.java
@@ -0,0 +1,95 @@
+/**
+ * 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.internal.operators.single;
+
+import io.reactivex.Single;
+import io.reactivex.TestHelper;
+import io.reactivex.exceptions.CompositeException;
+import io.reactivex.exceptions.TestException;
+import io.reactivex.functions.Action;
+import io.reactivex.observers.TestObserver;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static org.junit.Assert.assertTrue;
+
+public class SingleDoOnTerminateTest {
+
+    @Test(expected = NullPointerException.class)
+    public void doOnTerminate() {
+        Single.just(1).doOnTerminate(null);
+    }
+
+    @Test
+    public void doOnTerminateSuccess() {
+        final AtomicBoolean atomicBoolean = new AtomicBoolean();
+
+        Single.just(1).doOnTerminate(new Action() {
+            @Override
+            public void run() throws Exception {
+                atomicBoolean.set(true);
+            }
+        })
+        .test()
+        .assertResult(1);
+
+        assertTrue(atomicBoolean.get());
+    }
+
+    @Test
+    public void doOnTerminateError() {
+        final AtomicBoolean atomicBoolean = new AtomicBoolean();
+        Single.error(new TestException()).doOnTerminate(new Action() {
+            @Override
+            public void run() {
+                atomicBoolean.set(true);
+            }
+        })
+        .test()
+        .assertFailure(TestException.class);
+
+        assertTrue(atomicBoolean.get());
+    }
+
+    @Test
+    public void doOnTerminateSuccessCrash() {
+        Single.just(1).doOnTerminate(new Action() {
+            @Override
+            public void run() throws Exception {
+                throw new TestException();
+            }
+        })
+        .test()
+        .assertFailure(TestException.class);
+    }
+
+    @Test
+    public void doOnTerminateErrorCrash() {
+        TestObserver to = Single.error(new TestException("Outer")).doOnTerminate(new Action() {
+            @Override
+            public void run() {
+                throw new TestException("Inner");
+            }
+        })
+        .test()
+        .assertFailure(CompositeException.class);
+
+        List errors = TestHelper.compositeList(to.errors().get(0));
+
+        TestHelper.assertError(errors, 0, TestException.class, "Outer");
+        TestHelper.assertError(errors, 1, TestException.class, "Inner");
+    }
+}
diff --git a/src/test/java/io/reactivex/internal/operators/single/SingleFromCallableTest.java b/src/test/java/io/reactivex/internal/operators/single/SingleFromCallableTest.java
index 2c4ebcc321..23fb50c01d 100644
--- a/src/test/java/io/reactivex/internal/operators/single/SingleFromCallableTest.java
+++ b/src/test/java/io/reactivex/internal/operators/single/SingleFromCallableTest.java
@@ -33,7 +33,6 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 public class SingleFromCallableTest {
diff --git a/src/test/java/io/reactivex/internal/operators/single/SingleMiscTest.java b/src/test/java/io/reactivex/internal/operators/single/SingleMiscTest.java
index c811291851..7b3a891680 100644
--- a/src/test/java/io/reactivex/internal/operators/single/SingleMiscTest.java
+++ b/src/test/java/io/reactivex/internal/operators/single/SingleMiscTest.java
@@ -27,7 +27,9 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertSame;
 
@@ -199,11 +201,13 @@ public boolean test(Integer i, Throwable e) throws Exception {
 
     @Test
     public void retryTimes() {
+        final AtomicInteger calls = new AtomicInteger();
+
         Single.fromCallable(new Callable() {
-            int c;
+
             @Override
             public Object call() throws Exception {
-                if (++c != 5) {
+                if (calls.incrementAndGet() != 6) {
                     throw new TestException();
                 }
                 return 1;
@@ -212,6 +216,8 @@ public Object call() throws Exception {
         .retry(5)
         .test()
         .assertResult(1);
+
+        assertEquals(6, calls.get());
     }
 
     @Test
diff --git a/src/test/java/io/reactivex/internal/schedulers/IoScheduledReleaseTest.java b/src/test/java/io/reactivex/internal/schedulers/IoScheduledReleaseTest.java
new file mode 100644
index 0000000000..7eaaa377c0
--- /dev/null
+++ b/src/test/java/io/reactivex/internal/schedulers/IoScheduledReleaseTest.java
@@ -0,0 +1,58 @@
+/**
+ * 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.internal.schedulers;
+
+import io.reactivex.Completable;
+import io.reactivex.Flowable;
+import io.reactivex.annotations.NonNull;
+import io.reactivex.functions.Function;
+import io.reactivex.schedulers.Schedulers;
+import org.junit.Test;
+
+import java.util.concurrent.TimeUnit;
+
+public class IoScheduledReleaseTest {
+
+    /* This test will be stuck in a deadlock if IoScheduler.USE_SCHEDULED_RELEASE is not set */
+    @Test
+    public void scheduledRelease() {
+        boolean savedScheduledRelease = IoScheduler.USE_SCHEDULED_RELEASE;
+        IoScheduler.USE_SCHEDULED_RELEASE = true;
+        try {
+            Flowable.just("item")
+                    .observeOn(Schedulers.io())
+                    .firstOrError()
+                    .map(new Function() {
+                        @Override
+                        public String apply(@NonNull final String item) throws Exception {
+                            for (int i = 0; i < 50; i++) {
+                                Completable.complete()
+                                        .observeOn(Schedulers.io())
+                                        .blockingAwait();
+                            }
+                            return "Done";
+                        }
+                    })
+                    .ignoreElement()
+                    .test()
+                    .awaitDone(5, TimeUnit.SECONDS)
+                    .assertComplete();
+        } finally {
+            IoScheduler.USE_SCHEDULED_RELEASE = savedScheduledRelease;
+        }
+    }
+}
diff --git a/src/test/java/io/reactivex/internal/schedulers/SchedulerPoolFactoryTest.java b/src/test/java/io/reactivex/internal/schedulers/SchedulerPoolFactoryTest.java
index 603929ddb4..24b3daa801 100644
--- a/src/test/java/io/reactivex/internal/schedulers/SchedulerPoolFactoryTest.java
+++ b/src/test/java/io/reactivex/internal/schedulers/SchedulerPoolFactoryTest.java
@@ -18,12 +18,11 @@
 
 import static org.junit.Assert.*;
 
-import java.util.Properties;
-
 import org.junit.Test;
 
 import io.reactivex.TestHelper;
-import io.reactivex.internal.schedulers.SchedulerPoolFactory.PurgeProperties;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.functions.Functions;
 import io.reactivex.schedulers.Schedulers;
 
 public class SchedulerPoolFactoryTest {
@@ -78,53 +77,66 @@ public void run() {
     }
 
     @Test
-    public void loadPurgeProperties() {
-        Properties props1 = new Properties();
-
-        PurgeProperties pp = new PurgeProperties();
-        pp.load(props1);
-
-        assertTrue(pp.purgeEnable);
-        assertEquals(pp.purgePeriod, 1);
+    public void boolPropertiesDisabledReturnsDefaultDisabled() throws Throwable {
+        assertTrue(SchedulerPoolFactory.getBooleanProperty(false, "key", false, true, failingPropertiesAccessor));
+        assertFalse(SchedulerPoolFactory.getBooleanProperty(false, "key", true, false, failingPropertiesAccessor));
     }
 
     @Test
-    public void loadPurgePropertiesDisabled() {
-        Properties props1 = new Properties();
-        props1.setProperty(SchedulerPoolFactory.PURGE_ENABLED_KEY, "false");
+    public void boolPropertiesEnabledMissingReturnsDefaultMissing() throws Throwable {
+        assertTrue(SchedulerPoolFactory.getBooleanProperty(true, "key", true, false, missingPropertiesAccessor));
+        assertFalse(SchedulerPoolFactory.getBooleanProperty(true, "key", false, true, missingPropertiesAccessor));
+    }
 
-        PurgeProperties pp = new PurgeProperties();
-        pp.load(props1);
+    @Test
+    public void boolPropertiesFailureReturnsDefaultMissing() throws Throwable {
+        assertTrue(SchedulerPoolFactory.getBooleanProperty(true, "key", true, false, failingPropertiesAccessor));
+        assertFalse(SchedulerPoolFactory.getBooleanProperty(true, "key", false, true, failingPropertiesAccessor));
+    }
 
-        assertFalse(pp.purgeEnable);
-        assertEquals(pp.purgePeriod, 1);
+    @Test
+    public void boolPropertiesReturnsValue() throws Throwable {
+        assertTrue(SchedulerPoolFactory.getBooleanProperty(true, "true", true, false, Functions.identity()));
+        assertFalse(SchedulerPoolFactory.getBooleanProperty(true, "false", false, true, Functions.identity()));
     }
 
     @Test
-    public void loadPurgePropertiesEnabledCustomPeriod() {
-        Properties props1 = new Properties();
-        props1.setProperty(SchedulerPoolFactory.PURGE_ENABLED_KEY, "true");
-        props1.setProperty(SchedulerPoolFactory.PURGE_PERIOD_SECONDS_KEY, "2");
+    public void intPropertiesDisabledReturnsDefaultDisabled() throws Throwable {
+        assertEquals(-1, SchedulerPoolFactory.getIntProperty(false, "key", 0, -1, failingPropertiesAccessor));
+        assertEquals(-1, SchedulerPoolFactory.getIntProperty(false, "key", 1, -1, failingPropertiesAccessor));
+    }
 
-        PurgeProperties pp = new PurgeProperties();
-        pp.load(props1);
+    @Test
+    public void intPropertiesEnabledMissingReturnsDefaultMissing() throws Throwable {
+        assertEquals(-1, SchedulerPoolFactory.getIntProperty(true, "key", -1, 0, missingPropertiesAccessor));
+        assertEquals(-1, SchedulerPoolFactory.getIntProperty(true, "key", -1, 1, missingPropertiesAccessor));
+    }
 
-        assertTrue(pp.purgeEnable);
-        assertEquals(pp.purgePeriod, 2);
+    @Test
+    public void intPropertiesFailureReturnsDefaultMissing() throws Throwable {
+        assertEquals(-1, SchedulerPoolFactory.getIntProperty(true, "key", -1, 0, failingPropertiesAccessor));
+        assertEquals(-1, SchedulerPoolFactory.getIntProperty(true, "key", -1, 1, failingPropertiesAccessor));
     }
 
     @Test
-    public void loadPurgePropertiesEnabledCustomPeriodNaN() {
-        Properties props1 = new Properties();
-        props1.setProperty(SchedulerPoolFactory.PURGE_ENABLED_KEY, "true");
-        props1.setProperty(SchedulerPoolFactory.PURGE_PERIOD_SECONDS_KEY, "abc");
+    public void intPropertiesReturnsValue() throws Throwable {
+        assertEquals(1, SchedulerPoolFactory.getIntProperty(true, "1", 0, 4, Functions.identity()));
+        assertEquals(2, SchedulerPoolFactory.getIntProperty(true, "2", 3, 5, Functions.identity()));
+    }
 
-        PurgeProperties pp = new PurgeProperties();
-        pp.load(props1);
+    static final Function failingPropertiesAccessor = new Function() {
+        @Override
+        public String apply(String v) throws Exception {
+            throw new SecurityException();
+        }
+    };
 
-        assertTrue(pp.purgeEnable);
-        assertEquals(pp.purgePeriod, 1);
-    }
+    static final Function missingPropertiesAccessor = new Function() {
+        @Override
+        public String apply(String v) throws Exception {
+            return null;
+        }
+    };
 
     @Test
     public void putIntoPoolNoPurge() {
diff --git a/src/test/java/io/reactivex/internal/util/NotificationLiteTest.java b/src/test/java/io/reactivex/internal/util/NotificationLiteTest.java
index 36bfe52566..f6e463c7da 100644
--- a/src/test/java/io/reactivex/internal/util/NotificationLiteTest.java
+++ b/src/test/java/io/reactivex/internal/util/NotificationLiteTest.java
@@ -45,6 +45,6 @@ public void errorNotificationCompare() {
 
         assertEquals(ex.hashCode(), n1.hashCode());
 
-        assertFalse(n1.equals(NotificationLite.complete()));
+        assertNotEquals(n1, NotificationLite.complete());
     }
 }
diff --git a/src/test/java/io/reactivex/internal/util/VolatileSizeArrayListTest.java b/src/test/java/io/reactivex/internal/util/VolatileSizeArrayListTest.java
index 6086fff7e3..00d3119b32 100644
--- a/src/test/java/io/reactivex/internal/util/VolatileSizeArrayListTest.java
+++ b/src/test/java/io/reactivex/internal/util/VolatileSizeArrayListTest.java
@@ -82,22 +82,22 @@ public void normal() {
         VolatileSizeArrayList list2 = new VolatileSizeArrayList();
         list2.addAll(Arrays.asList(1, 2, 3, 4, 5, 6));
 
-        assertFalse(list2.equals(list));
-        assertFalse(list.equals(list2));
+        assertNotEquals(list2, list);
+        assertNotEquals(list, list2);
 
         list2.add(7);
-        assertTrue(list2.equals(list));
-        assertTrue(list.equals(list2));
+        assertEquals(list2, list);
+        assertEquals(list, list2);
 
         List list3 = new ArrayList();
         list3.addAll(Arrays.asList(1, 2, 3, 4, 5, 6));
 
-        assertFalse(list3.equals(list));
-        assertFalse(list.equals(list3));
+        assertNotEquals(list3, list);
+        assertNotEquals(list, list3);
 
         list3.add(7);
-        assertTrue(list3.equals(list));
-        assertTrue(list.equals(list3));
+        assertEquals(list3, list);
+        assertEquals(list, list3);
 
         assertEquals(list.hashCode(), list3.hashCode());
         assertEquals(list.toString(), list3.toString());
diff --git a/src/test/java/io/reactivex/maybe/MaybeTest.java b/src/test/java/io/reactivex/maybe/MaybeTest.java
index 41225a47cc..45b31b0a8a 100644
--- a/src/test/java/io/reactivex/maybe/MaybeTest.java
+++ b/src/test/java/io/reactivex/maybe/MaybeTest.java
@@ -3185,6 +3185,19 @@ public Publisher apply(Flowable v) throws Exception
                 return (Publisher)v;
             }
         }).test().assertResult(1);
+
+        final AtomicInteger calls = new AtomicInteger();
+        try {
+            Maybe.error(new Callable() {
+                @Override
+                public Throwable call() {
+                    calls.incrementAndGet();
+                    return new TestException();
+                }
+            }).retry(5).test();
+        } finally {
+            assertEquals(6, calls.get());
+        }
     }
 
     @Test
diff --git a/src/test/java/io/reactivex/observable/ObservableMergeTests.java b/src/test/java/io/reactivex/observable/ObservableMergeTests.java
index c7ee01c591..1d68a5d28e 100644
--- a/src/test/java/io/reactivex/observable/ObservableMergeTests.java
+++ b/src/test/java/io/reactivex/observable/ObservableMergeTests.java
@@ -68,7 +68,7 @@ public void testMergeCovariance3() {
 
         assertTrue(values.get(0) instanceof HorrorMovie);
         assertTrue(values.get(1) instanceof Movie);
-        assertTrue(values.get(2) != null);
+        assertNotNull(values.get(2));
         assertTrue(values.get(3) instanceof HorrorMovie);
     }
 
@@ -91,7 +91,7 @@ public Observable call() {
 
         assertTrue(values.get(0) instanceof HorrorMovie);
         assertTrue(values.get(1) instanceof Movie);
-        assertTrue(values.get(2) != null);
+        assertNotNull(values.get(2));
         assertTrue(values.get(3) instanceof HorrorMovie);
     }
 
diff --git a/src/test/java/io/reactivex/observable/ObservableTest.java b/src/test/java/io/reactivex/observable/ObservableTest.java
index ab915ffa53..f59a41857e 100644
--- a/src/test/java/io/reactivex/observable/ObservableTest.java
+++ b/src/test/java/io/reactivex/observable/ObservableTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.observable;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
diff --git a/src/test/java/io/reactivex/observable/ObservableWindowTests.java b/src/test/java/io/reactivex/observable/ObservableWindowTests.java
index d4c68fd63b..701b07e0b7 100644
--- a/src/test/java/io/reactivex/observable/ObservableWindowTests.java
+++ b/src/test/java/io/reactivex/observable/ObservableWindowTests.java
@@ -16,11 +16,16 @@
 import static org.junit.Assert.*;
 
 import java.util.*;
+import java.util.concurrent.TimeUnit;
 
 import org.junit.Test;
 
 import io.reactivex.Observable;
+import io.reactivex.SingleSource;
 import io.reactivex.functions.*;
+import io.reactivex.observers.TestObserver;
+import io.reactivex.schedulers.TestScheduler;
+import io.reactivex.subjects.PublishSubject;
 
 public class ObservableWindowTests {
 
@@ -50,4 +55,43 @@ public void accept(List xs) {
         assertEquals(2, lists.size());
 
     }
+
+    @Test
+    public void timeSizeWindowAlternatingBounds() {
+        TestScheduler scheduler = new TestScheduler();
+        PublishSubject ps = PublishSubject.create();
+
+        TestObserver> to = ps.window(5, TimeUnit.SECONDS, scheduler, 2)
+        .flatMapSingle(new Function, SingleSource>>() {
+            @Override
+            public SingleSource> apply(Observable v) {
+                return v.toList();
+            }
+        })
+        .test();
+
+        ps.onNext(1);
+        ps.onNext(2);
+        to.assertValueCount(1); // size bound hit
+
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        ps.onNext(3);
+        scheduler.advanceTimeBy(6, TimeUnit.SECONDS);
+        to.assertValueCount(2); // time bound hit
+
+        ps.onNext(4);
+        ps.onNext(5);
+
+        to.assertValueCount(3); // size bound hit again
+
+        ps.onNext(4);
+
+        scheduler.advanceTimeBy(6, TimeUnit.SECONDS);
+
+        to.assertValueCount(4)
+        .assertNoErrors()
+        .assertNotComplete();
+
+        to.dispose();
+    }
 }
diff --git a/src/test/java/io/reactivex/plugins/RxJavaPluginsTest.java b/src/test/java/io/reactivex/plugins/RxJavaPluginsTest.java
index efd4642d7e..229dc7c873 100644
--- a/src/test/java/io/reactivex/plugins/RxJavaPluginsTest.java
+++ b/src/test/java/io/reactivex/plugins/RxJavaPluginsTest.java
@@ -2070,7 +2070,7 @@ public void run() {
 
             Thread t = value.get();
             assertNotNull(t);
-            assertTrue(expectedThreadName.equals(t.getName()));
+            assertEquals(expectedThreadName, t.getName());
         } catch (Exception e) {
             fail();
         } finally {
diff --git a/src/test/java/io/reactivex/processors/AsyncProcessorTest.java b/src/test/java/io/reactivex/processors/AsyncProcessorTest.java
index 963171d30e..3d85d97eee 100644
--- a/src/test/java/io/reactivex/processors/AsyncProcessorTest.java
+++ b/src/test/java/io/reactivex/processors/AsyncProcessorTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.processors;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.concurrent.TimeUnit;
diff --git a/src/test/java/io/reactivex/processors/BehaviorProcessorTest.java b/src/test/java/io/reactivex/processors/BehaviorProcessorTest.java
index a0e3996f41..d465aa7a56 100644
--- a/src/test/java/io/reactivex/processors/BehaviorProcessorTest.java
+++ b/src/test/java/io/reactivex/processors/BehaviorProcessorTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.processors;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/processors/MulticastProcessorTest.java b/src/test/java/io/reactivex/processors/MulticastProcessorTest.java
index 63a7b1a60b..d541dffb3e 100644
--- a/src/test/java/io/reactivex/processors/MulticastProcessorTest.java
+++ b/src/test/java/io/reactivex/processors/MulticastProcessorTest.java
@@ -783,4 +783,41 @@ public void noUpstream() {
         assertTrue(mp.hasSubscribers());
     }
 
+    @Test
+    public void requestUpstreamPrefetchNonFused() {
+        for (int j = 1; j < 12; j++) {
+            MulticastProcessor mp = MulticastProcessor.create(j, true);
+
+            TestSubscriber ts = mp.test(0).withTag("Prefetch: " + j);
+
+            Flowable.range(1, 10).hide().subscribe(mp);
+
+            ts.assertEmpty()
+            .requestMore(3)
+            .assertValuesOnly(1, 2, 3)
+            .requestMore(3)
+            .assertValuesOnly(1, 2, 3, 4, 5, 6)
+            .requestMore(4)
+            .assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+        }
+    }
+
+    @Test
+    public void requestUpstreamPrefetchNonFused2() {
+        for (int j = 1; j < 12; j++) {
+            MulticastProcessor mp = MulticastProcessor.create(j, true);
+
+            TestSubscriber ts = mp.test(0).withTag("Prefetch: " + j);
+
+            Flowable.range(1, 10).hide().subscribe(mp);
+
+            ts.assertEmpty()
+            .requestMore(2)
+            .assertValuesOnly(1, 2)
+            .requestMore(2)
+            .assertValuesOnly(1, 2, 3, 4)
+            .requestMore(6)
+            .assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+        }
+    }
 }
diff --git a/src/test/java/io/reactivex/processors/PublishProcessorTest.java b/src/test/java/io/reactivex/processors/PublishProcessorTest.java
index f91e61551f..980ed84187 100644
--- a/src/test/java/io/reactivex/processors/PublishProcessorTest.java
+++ b/src/test/java/io/reactivex/processors/PublishProcessorTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.processors;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.ArrayList;
diff --git a/src/test/java/io/reactivex/processors/ReplayProcessorTest.java b/src/test/java/io/reactivex/processors/ReplayProcessorTest.java
index 810e80d9e5..b59d20fb94 100644
--- a/src/test/java/io/reactivex/processors/ReplayProcessorTest.java
+++ b/src/test/java/io/reactivex/processors/ReplayProcessorTest.java
@@ -14,21 +14,21 @@
 package io.reactivex.processors;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
+import java.lang.management.*;
 import java.util.Arrays;
 import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.atomic.*;
 
-import org.junit.Test;
+import org.junit.*;
 import org.mockito.*;
 import org.reactivestreams.*;
 
 import io.reactivex.*;
 import io.reactivex.disposables.Disposable;
 import io.reactivex.exceptions.TestException;
-import io.reactivex.functions.Function;
+import io.reactivex.functions.*;
 import io.reactivex.internal.subscriptions.BooleanSubscription;
 import io.reactivex.processors.ReplayProcessor.*;
 import io.reactivex.schedulers.*;
@@ -1050,7 +1050,7 @@ public void peekStateTimeAndSizeValueExpired() {
 
         scheduler.advanceTimeBy(2, TimeUnit.DAYS);
 
-        assertEquals(null, rp.getValue());
+        assertNull(rp.getValue());
         assertEquals(0, rp.getValues().length);
         assertNull(rp.getValues(new Integer[2])[0]);
     }
@@ -1692,4 +1692,137 @@ public void noHeadRetentionTime() {
     public void invalidRequest() {
         TestHelper.assertBadRequestReported(ReplayProcessor.create());
     }
+
+    @Test
+    public void noBoundedRetentionViaThreadLocal() throws Exception {
+        final ReplayProcessor rp = ReplayProcessor.createWithSize(1);
+
+        Flowable source = rp.take(1)
+        .concatMap(new Function>() {
+            @Override
+            public Publisher apply(byte[] v) throws Exception {
+                return rp;
+            }
+        })
+        .takeLast(1)
+        ;
+
+        System.out.println("Bounded Replay Leak check: Wait before GC");
+        Thread.sleep(1000);
+
+        System.out.println("Bounded Replay Leak check: GC");
+        System.gc();
+
+        Thread.sleep(500);
+
+        final MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
+        MemoryUsage memHeap = memoryMXBean.getHeapMemoryUsage();
+        long initial = memHeap.getUsed();
+
+        System.out.printf("Bounded Replay Leak check: Starting: %.3f MB%n", initial / 1024.0 / 1024.0);
+
+        final AtomicLong after = new AtomicLong();
+
+        source.subscribe(new Consumer() {
+            @Override
+            public void accept(byte[] v) throws Exception {
+                System.out.println("Bounded Replay Leak check: Wait before GC 2");
+                Thread.sleep(1000);
+
+                System.out.println("Bounded Replay Leak check:  GC 2");
+                System.gc();
+
+                Thread.sleep(500);
+
+                after.set(memoryMXBean.getHeapMemoryUsage().getUsed());
+            }
+        });
+
+        for (int i = 0; i < 200; i++) {
+            rp.onNext(new byte[1024 * 1024]);
+        }
+        rp.onComplete();
+
+        System.out.printf("Bounded Replay Leak check: After: %.3f MB%n", after.get() / 1024.0 / 1024.0);
+
+        if (initial + 100 * 1024 * 1024 < after.get()) {
+            Assert.fail("Bounded Replay Leak check: Memory leak detected: " + (initial / 1024.0 / 1024.0)
+                    + " -> " + after.get() / 1024.0 / 1024.0);
+        }
+    }
+
+    @Test
+    public void timeAndSizeNoTerminalTruncationOnTimechange() {
+        ReplayProcessor rp = ReplayProcessor.createWithTimeAndSize(1, TimeUnit.SECONDS, new TimesteppingScheduler(), 1);
+
+        TestSubscriber ts = rp.test();
+
+        rp.onNext(1);
+        rp.cleanupBuffer();
+        rp.onComplete();
+
+        ts.assertNoErrors()
+        .assertComplete();
+    }
+
+    @Test
+    public void timeAndSizeNoTerminalTruncationOnTimechange2() {
+        ReplayProcessor rp = ReplayProcessor.createWithTimeAndSize(1, TimeUnit.SECONDS, new TimesteppingScheduler(), 1);
+
+        TestSubscriber ts = rp.test();
+
+        rp.onNext(1);
+        rp.cleanupBuffer();
+        rp.onNext(2);
+        rp.cleanupBuffer();
+        rp.onComplete();
+
+        ts.assertNoErrors()
+        .assertComplete();
+    }
+
+    @Test
+    public void timeAndSizeNoTerminalTruncationOnTimechange3() {
+        ReplayProcessor rp = ReplayProcessor.createWithTimeAndSize(1, TimeUnit.SECONDS, new TimesteppingScheduler(), 1);
+
+        TestSubscriber ts = rp.test();
+
+        rp.onNext(1);
+        rp.onNext(2);
+        rp.onComplete();
+
+        ts.assertNoErrors()
+        .assertComplete();
+    }
+
+    @Test
+    public void timeAndSizeNoTerminalTruncationOnTimechange4() {
+        ReplayProcessor rp = ReplayProcessor.createWithTimeAndSize(1, TimeUnit.SECONDS, new TimesteppingScheduler(), 10);
+
+        TestSubscriber ts = rp.test();
+
+        rp.onNext(1);
+        rp.onNext(2);
+        rp.onComplete();
+
+        ts.assertNoErrors()
+        .assertComplete();
+    }
+
+    @Test
+    public void timeAndSizeRemoveCorrectNumberOfOld() {
+        TestScheduler scheduler = new TestScheduler();
+        ReplayProcessor rp = ReplayProcessor.createWithTimeAndSize(1, TimeUnit.SECONDS, scheduler, 2);
+
+        rp.onNext(1);
+        rp.onNext(2);
+        rp.onNext(3);
+
+        scheduler.advanceTimeBy(2, TimeUnit.SECONDS);
+
+        rp.onNext(4);
+        rp.onNext(5);
+
+        rp.test().assertValuesOnly(4, 5);
+    }
 }
diff --git a/src/test/java/io/reactivex/processors/UnicastProcessorTest.java b/src/test/java/io/reactivex/processors/UnicastProcessorTest.java
index 5bbe6dca75..7b96e03b53 100644
--- a/src/test/java/io/reactivex/processors/UnicastProcessorTest.java
+++ b/src/test/java/io/reactivex/processors/UnicastProcessorTest.java
@@ -16,16 +16,20 @@
 import static org.junit.Assert.*;
 
 import java.util.List;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.Test;
 
 import io.reactivex.*;
 import io.reactivex.disposables.Disposable;
-import io.reactivex.exceptions.TestException;
-import io.reactivex.internal.fuseable.*;
+import io.reactivex.exceptions.*;
+import io.reactivex.internal.functions.Functions;
+import io.reactivex.internal.fuseable.QueueFuseable;
 import io.reactivex.internal.subscriptions.BooleanSubscription;
+import io.reactivex.observers.TestObserver;
 import io.reactivex.plugins.RxJavaPlugins;
+import io.reactivex.schedulers.Schedulers;
 import io.reactivex.subscribers.*;
 
 public class UnicastProcessorTest extends FlowableProcessorTest {
@@ -132,9 +136,9 @@ public void onTerminateCalledWhenOnError() {
             }
         });
 
-        assertEquals(false, didRunOnTerminate.get());
+        assertFalse(didRunOnTerminate.get());
         us.onError(new RuntimeException("some error"));
-        assertEquals(true, didRunOnTerminate.get());
+        assertTrue(didRunOnTerminate.get());
     }
 
     @Test
@@ -147,9 +151,9 @@ public void onTerminateCalledWhenOnComplete() {
             }
         });
 
-        assertEquals(false, didRunOnTerminate.get());
+        assertFalse(didRunOnTerminate.get());
         us.onComplete();
-        assertEquals(true, didRunOnTerminate.get());
+        assertTrue(didRunOnTerminate.get());
     }
 
     @Test
@@ -164,9 +168,9 @@ public void onTerminateCalledWhenCanceled() {
 
         final Disposable subscribe = us.subscribe();
 
-        assertEquals(false, didRunOnTerminate.get());
+        assertFalse(didRunOnTerminate.get());
         subscribe.dispose();
-        assertEquals(true, didRunOnTerminate.get());
+        assertTrue(didRunOnTerminate.get());
     }
 
     @Test(expected = NullPointerException.class)
@@ -438,4 +442,37 @@ public void unicastSubscriptionBadRequest() {
             RxJavaPlugins.reset();
         }
     }
+
+    @Test
+    public void fusedNoConcurrentCleanDueToCancel() {
+        for (int j = 0; j < TestHelper.RACE_LONG_LOOPS; j++) {
+            List errors = TestHelper.trackPluginErrors();
+            try {
+                final UnicastProcessor us = UnicastProcessor.create();
+
+                TestObserver to = us
+                .observeOn(Schedulers.io())
+                .map(Functions.identity())
+                .observeOn(Schedulers.single())
+                .firstOrError()
+                .test();
+
+                for (int i = 0; us.hasSubscribers(); i++) {
+                    us.onNext(i);
+                }
+
+                to
+                .awaitDone(5, TimeUnit.SECONDS)
+                ;
+
+                if (!errors.isEmpty()) {
+                    throw new CompositeException(errors);
+                }
+
+                to.assertResult(0);
+            } finally {
+                RxJavaPlugins.reset();
+            }
+        }
+    }
 }
diff --git a/src/test/java/io/reactivex/schedulers/AbstractSchedulerConcurrencyTests.java b/src/test/java/io/reactivex/schedulers/AbstractSchedulerConcurrencyTests.java
index 3605c74679..af489f5650 100644
--- a/src/test/java/io/reactivex/schedulers/AbstractSchedulerConcurrencyTests.java
+++ b/src/test/java/io/reactivex/schedulers/AbstractSchedulerConcurrencyTests.java
@@ -405,7 +405,7 @@ public void accept(Integer t) {
                     throw new RuntimeException("The latch should have released if we are async.", e);
                 }
 
-                assertFalse(Thread.currentThread().getName().equals(currentThreadName));
+                assertNotEquals(Thread.currentThread().getName(), currentThreadName);
                 System.out.println("Thread: " + Thread.currentThread().getName());
                 System.out.println("t: " + t);
                 count.incrementAndGet();
diff --git a/src/test/java/io/reactivex/schedulers/ComputationSchedulerTests.java b/src/test/java/io/reactivex/schedulers/ComputationSchedulerTests.java
index b33efed40b..86ae8ac54e 100644
--- a/src/test/java/io/reactivex/schedulers/ComputationSchedulerTests.java
+++ b/src/test/java/io/reactivex/schedulers/ComputationSchedulerTests.java
@@ -122,7 +122,7 @@ public final void testMergeWithExecutorScheduler() {
 
             @Override
             public String apply(Integer t) {
-                assertFalse(Thread.currentThread().getName().equals(currentThreadName));
+                assertNotEquals(Thread.currentThread().getName(), currentThreadName);
                 assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool"));
                 return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
             }
diff --git a/src/test/java/io/reactivex/schedulers/ExecutorSchedulerInterruptibleTest.java b/src/test/java/io/reactivex/schedulers/ExecutorSchedulerInterruptibleTest.java
new file mode 100644
index 0000000000..bccca7524e
--- /dev/null
+++ b/src/test/java/io/reactivex/schedulers/ExecutorSchedulerInterruptibleTest.java
@@ -0,0 +1,664 @@
+/**
+ * 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.schedulers;
+
+import static org.junit.Assert.*;
+
+import java.lang.management.*;
+import java.util.List;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
+
+import org.junit.*;
+
+import io.reactivex.*;
+import io.reactivex.Scheduler.Worker;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.internal.functions.Functions;
+import io.reactivex.internal.schedulers.*;
+import io.reactivex.plugins.RxJavaPlugins;
+
+public class ExecutorSchedulerInterruptibleTest extends AbstractSchedulerConcurrencyTests {
+
+    static final Executor executor = Executors.newFixedThreadPool(2, new RxThreadFactory("TestCustomPool"));
+
+    @Override
+    protected Scheduler getScheduler() {
+        return Schedulers.from(executor, true);
+    }
+
+    @Test
+    @Ignore("Unhandled errors are no longer thrown")
+    public final void testUnhandledErrorIsDeliveredToThreadHandler() throws InterruptedException {
+        SchedulerTestHelper.testUnhandledErrorIsDeliveredToThreadHandler(getScheduler());
+    }
+
+    @Test
+    public final void testHandledErrorIsNotDeliveredToThreadHandler() throws InterruptedException {
+        SchedulerTestHelper.testHandledErrorIsNotDeliveredToThreadHandler(getScheduler());
+    }
+
+    public static void testCancelledRetention(Scheduler.Worker w, boolean periodic) throws InterruptedException {
+        System.out.println("Wait before GC");
+        Thread.sleep(1000);
+
+        System.out.println("GC");
+        System.gc();
+
+        Thread.sleep(1000);
+
+        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
+        MemoryUsage memHeap = memoryMXBean.getHeapMemoryUsage();
+        long initial = memHeap.getUsed();
+
+        System.out.printf("Starting: %.3f MB%n", initial / 1024.0 / 1024.0);
+
+        int n = 100 * 1000;
+        if (periodic) {
+            final CountDownLatch cdl = new CountDownLatch(n);
+            final Runnable action = new Runnable() {
+                @Override
+                public void run() {
+                    cdl.countDown();
+                }
+            };
+            for (int i = 0; i < n; i++) {
+                if (i % 50000 == 0) {
+                    System.out.println("  -> still scheduling: " + i);
+                }
+                w.schedulePeriodically(action, 0, 1, TimeUnit.DAYS);
+            }
+
+            System.out.println("Waiting for the first round to finish...");
+            cdl.await();
+        } else {
+            for (int i = 0; i < n; i++) {
+                if (i % 50000 == 0) {
+                    System.out.println("  -> still scheduling: " + i);
+                }
+                w.schedule(Functions.EMPTY_RUNNABLE, 1, TimeUnit.DAYS);
+            }
+        }
+
+        memHeap = memoryMXBean.getHeapMemoryUsage();
+        long after = memHeap.getUsed();
+        System.out.printf("Peak: %.3f MB%n", after / 1024.0 / 1024.0);
+
+        w.dispose();
+
+        System.out.println("Wait before second GC");
+        System.out.println("JDK 6 purge is N log N because it removes and shifts one by one");
+        int t = (int)(n * Math.log(n) / 100) + SchedulerPoolFactory.PURGE_PERIOD_SECONDS * 1000;
+        while (t > 0) {
+            System.out.printf("  >> Waiting for purge: %.2f s remaining%n", t / 1000d);
+
+            System.gc();
+
+            Thread.sleep(1000);
+
+            t -= 1000;
+            memHeap = memoryMXBean.getHeapMemoryUsage();
+            long finish = memHeap.getUsed();
+            System.out.printf("After: %.3f MB%n", finish / 1024.0 / 1024.0);
+            if (finish <= initial * 5) {
+                break;
+            }
+        }
+
+        System.out.println("Second GC");
+        System.gc();
+
+        Thread.sleep(1000);
+
+        memHeap = memoryMXBean.getHeapMemoryUsage();
+        long finish = memHeap.getUsed();
+        System.out.printf("After: %.3f MB%n", finish / 1024.0 / 1024.0);
+
+        if (finish > initial * 5) {
+            fail(String.format("Tasks retained: %.3f -> %.3f -> %.3f", initial / 1024 / 1024.0, after / 1024 / 1024.0, finish / 1024 / 1024d));
+        }
+    }
+
+    @Test(timeout = 60000)
+    public void testCancelledTaskRetention() throws InterruptedException {
+        ExecutorService exec = Executors.newSingleThreadExecutor();
+        Scheduler s = Schedulers.from(exec, true);
+        try {
+            Scheduler.Worker w = s.createWorker();
+            try {
+                testCancelledRetention(w, false);
+            } finally {
+                w.dispose();
+            }
+
+            w = s.createWorker();
+            try {
+                testCancelledRetention(w, true);
+            } finally {
+                w.dispose();
+            }
+        } finally {
+            exec.shutdownNow();
+        }
+    }
+
+    /** A simple executor which queues tasks and executes them one-by-one if executeOne() is called. */
+    static final class TestExecutor implements Executor {
+        final ConcurrentLinkedQueue queue = new ConcurrentLinkedQueue();
+        @Override
+        public void execute(Runnable command) {
+            queue.offer(command);
+        }
+        public void executeOne() {
+            Runnable r = queue.poll();
+            if (r != null) {
+                r.run();
+            }
+        }
+        public void executeAll() {
+            Runnable r;
+            while ((r = queue.poll()) != null) {
+                r.run();
+            }
+        }
+    }
+
+    @Test
+    public void testCancelledTasksDontRun() {
+        final AtomicInteger calls = new AtomicInteger();
+        Runnable task = new Runnable() {
+            @Override
+            public void run() {
+                calls.getAndIncrement();
+            }
+        };
+        TestExecutor exec = new TestExecutor();
+        Scheduler custom = Schedulers.from(exec, true);
+        Worker w = custom.createWorker();
+        try {
+            Disposable d1 = w.schedule(task);
+            Disposable d2 = w.schedule(task);
+            Disposable d3 = w.schedule(task);
+
+            d1.dispose();
+            d2.dispose();
+            d3.dispose();
+
+            exec.executeAll();
+
+            assertEquals(0, calls.get());
+        } finally {
+            w.dispose();
+        }
+    }
+
+    @Test
+    public void testCancelledWorkerDoesntRunTasks() {
+        final AtomicInteger calls = new AtomicInteger();
+        Runnable task = new Runnable() {
+            @Override
+            public void run() {
+                calls.getAndIncrement();
+            }
+        };
+        TestExecutor exec = new TestExecutor();
+        Scheduler custom = Schedulers.from(exec, true);
+        Worker w = custom.createWorker();
+        try {
+            w.schedule(task);
+            w.schedule(task);
+            w.schedule(task);
+        } finally {
+            w.dispose();
+        }
+        exec.executeAll();
+        assertEquals(0, calls.get());
+    }
+
+    // FIXME the internal structure changed and these can't be tested
+//
+//    @Test
+//    public void testNoTimedTaskAfterScheduleRetention() throws InterruptedException {
+//        Executor e = new Executor() {
+//            @Override
+//            public void execute(Runnable command) {
+//                command.run();
+//            }
+//        };
+//        ExecutorWorker w = (ExecutorWorker)Schedulers.from(e, true).createWorker();
+//
+//        w.schedule(Functions.emptyRunnable(), 50, TimeUnit.MILLISECONDS);
+//
+//        assertTrue(w.tasks.hasSubscriptions());
+//
+//        Thread.sleep(150);
+//
+//        assertFalse(w.tasks.hasSubscriptions());
+//    }
+//
+//    @Test
+//    public void testNoTimedTaskPartRetention() {
+//        Executor e = new Executor() {
+//            @Override
+//            public void execute(Runnable command) {
+//
+//            }
+//        };
+//        ExecutorWorker w = (ExecutorWorker)Schedulers.from(e, true).createWorker();
+//
+//        Disposable task = w.schedule(Functions.emptyRunnable(), 1, TimeUnit.DAYS);
+//
+//        assertTrue(w.tasks.hasSubscriptions());
+//
+//        task.dispose();
+//
+//        assertFalse(w.tasks.hasSubscriptions());
+//    }
+//
+//    @Test
+//    public void testNoPeriodicTimedTaskPartRetention() throws InterruptedException {
+//        Executor e = new Executor() {
+//            @Override
+//            public void execute(Runnable command) {
+//                command.run();
+//            }
+//        };
+//        ExecutorWorker w = (ExecutorWorker)Schedulers.from(e, true).createWorker();
+//
+//        final CountDownLatch cdl = new CountDownLatch(1);
+//        final Runnable action = new Runnable() {
+//            @Override
+//            public void run() {
+//                cdl.countDown();
+//            }
+//        };
+//
+//        Disposable task = w.schedulePeriodically(action, 0, 1, TimeUnit.DAYS);
+//
+//        assertTrue(w.tasks.hasSubscriptions());
+//
+//        cdl.await();
+//
+//        task.dispose();
+//
+//        assertFalse(w.tasks.hasSubscriptions());
+//    }
+
+    @Test
+    public void plainExecutor() throws Exception {
+        Scheduler s = Schedulers.from(new Executor() {
+            @Override
+            public void execute(Runnable r) {
+                r.run();
+            }
+        }, true);
+
+        final CountDownLatch cdl = new CountDownLatch(5);
+
+        Runnable r = new Runnable() {
+            @Override
+            public void run() {
+                cdl.countDown();
+            }
+        };
+
+        s.scheduleDirect(r);
+
+        s.scheduleDirect(r, 50, TimeUnit.MILLISECONDS);
+
+        Disposable d = s.schedulePeriodicallyDirect(r, 10, 10, TimeUnit.MILLISECONDS);
+
+        try {
+            assertTrue(cdl.await(5, TimeUnit.SECONDS));
+        } finally {
+            d.dispose();
+        }
+
+        assertTrue(d.isDisposed());
+    }
+
+    @Test
+    public void rejectingExecutor() {
+        ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
+        exec.shutdown();
+
+        Scheduler s = Schedulers.from(exec, true);
+
+        List errors = TestHelper.trackPluginErrors();
+
+        try {
+            assertSame(EmptyDisposable.INSTANCE, s.scheduleDirect(Functions.EMPTY_RUNNABLE));
+
+            assertSame(EmptyDisposable.INSTANCE, s.scheduleDirect(Functions.EMPTY_RUNNABLE, 10, TimeUnit.MILLISECONDS));
+
+            assertSame(EmptyDisposable.INSTANCE, s.schedulePeriodicallyDirect(Functions.EMPTY_RUNNABLE, 10, 10, TimeUnit.MILLISECONDS));
+
+            TestHelper.assertUndeliverable(errors, 0, RejectedExecutionException.class);
+            TestHelper.assertUndeliverable(errors, 1, RejectedExecutionException.class);
+            TestHelper.assertUndeliverable(errors, 2, RejectedExecutionException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    @Test
+    public void rejectingExecutorWorker() {
+        ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
+        exec.shutdown();
+
+        List errors = TestHelper.trackPluginErrors();
+
+        try {
+            Worker s = Schedulers.from(exec, true).createWorker();
+            assertSame(EmptyDisposable.INSTANCE, s.schedule(Functions.EMPTY_RUNNABLE));
+
+            s = Schedulers.from(exec, true).createWorker();
+            assertSame(EmptyDisposable.INSTANCE, s.schedule(Functions.EMPTY_RUNNABLE, 10, TimeUnit.MILLISECONDS));
+
+            s = Schedulers.from(exec, true).createWorker();
+            assertSame(EmptyDisposable.INSTANCE, s.schedulePeriodically(Functions.EMPTY_RUNNABLE, 10, 10, TimeUnit.MILLISECONDS));
+
+            TestHelper.assertUndeliverable(errors, 0, RejectedExecutionException.class);
+            TestHelper.assertUndeliverable(errors, 1, RejectedExecutionException.class);
+            TestHelper.assertUndeliverable(errors, 2, RejectedExecutionException.class);
+        } finally {
+            RxJavaPlugins.reset();
+        }
+    }
+
+    @Test
+    public void reuseScheduledExecutor() throws Exception {
+        ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
+
+        try {
+            Scheduler s = Schedulers.from(exec, true);
+
+            final CountDownLatch cdl = new CountDownLatch(8);
+
+            Runnable r = new Runnable() {
+                @Override
+                public void run() {
+                    cdl.countDown();
+                }
+            };
+
+            s.scheduleDirect(r);
+
+            s.scheduleDirect(r, 10, TimeUnit.MILLISECONDS);
+
+            Disposable d = s.schedulePeriodicallyDirect(r, 10, 10, TimeUnit.MILLISECONDS);
+
+            try {
+                assertTrue(cdl.await(5, TimeUnit.SECONDS));
+            } finally {
+                d.dispose();
+            }
+        } finally {
+            exec.shutdown();
+        }
+    }
+
+    @Test
+    public void reuseScheduledExecutorAsWorker() throws Exception {
+        ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
+
+        Worker s = Schedulers.from(exec, true).createWorker();
+
+        assertFalse(s.isDisposed());
+        try {
+
+            final CountDownLatch cdl = new CountDownLatch(8);
+
+            Runnable r = new Runnable() {
+                @Override
+                public void run() {
+                    cdl.countDown();
+                }
+            };
+
+            s.schedule(r);
+
+            s.schedule(r, 10, TimeUnit.MILLISECONDS);
+
+            Disposable d = s.schedulePeriodically(r, 10, 10, TimeUnit.MILLISECONDS);
+
+            try {
+                assertTrue(cdl.await(5, TimeUnit.SECONDS));
+            } finally {
+                d.dispose();
+            }
+        } finally {
+            s.dispose();
+            exec.shutdown();
+        }
+
+        assertTrue(s.isDisposed());
+    }
+
+    @Test
+    public void disposeRace() {
+        ExecutorService exec = Executors.newSingleThreadExecutor();
+        final Scheduler s = Schedulers.from(exec, true);
+        try {
+            for (int i = 0; i < 500; i++) {
+                final Worker w = s.createWorker();
+
+                final AtomicInteger c = new AtomicInteger(2);
+
+                w.schedule(new Runnable() {
+                    @Override
+                    public void run() {
+                        c.decrementAndGet();
+                        while (c.get() != 0) { }
+                    }
+                });
+
+                c.decrementAndGet();
+                while (c.get() != 0) { }
+                w.dispose();
+            }
+        } finally {
+            exec.shutdownNow();
+        }
+    }
+
+    @Test
+    public void runnableDisposed() {
+        final Scheduler s = Schedulers.from(new Executor() {
+            @Override
+            public void execute(Runnable r) {
+                r.run();
+            }
+        }, true);
+        Disposable d = s.scheduleDirect(Functions.EMPTY_RUNNABLE);
+
+        assertTrue(d.isDisposed());
+    }
+
+    @Test(timeout = 1000)
+    public void runnableDisposedAsync() throws Exception {
+        final Scheduler s = Schedulers.from(new Executor() {
+            @Override
+            public void execute(Runnable r) {
+                new Thread(r).start();
+            }
+        }, true);
+        Disposable d = s.scheduleDirect(Functions.EMPTY_RUNNABLE);
+
+        while (!d.isDisposed()) {
+            Thread.sleep(1);
+        }
+    }
+
+    @Test(timeout = 1000)
+    public void runnableDisposedAsync2() throws Exception {
+        final Scheduler s = Schedulers.from(executor, true);
+        Disposable d = s.scheduleDirect(Functions.EMPTY_RUNNABLE);
+
+        while (!d.isDisposed()) {
+            Thread.sleep(1);
+        }
+    }
+
+    @Test(timeout = 1000)
+    public void runnableDisposedAsyncCrash() throws Exception {
+        final Scheduler s = Schedulers.from(new Executor() {
+            @Override
+            public void execute(Runnable r) {
+                new Thread(r).start();
+            }
+        }, true);
+        Disposable d = s.scheduleDirect(new Runnable() {
+            @Override
+            public void run() {
+                throw new IllegalStateException();
+            }
+        });
+
+        while (!d.isDisposed()) {
+            Thread.sleep(1);
+        }
+    }
+
+    @Test(timeout = 1000)
+    public void runnableDisposedAsyncTimed() throws Exception {
+        final Scheduler s = Schedulers.from(new Executor() {
+            @Override
+            public void execute(Runnable r) {
+                new Thread(r).start();
+            }
+        }, true);
+        Disposable d = s.scheduleDirect(Functions.EMPTY_RUNNABLE, 1, TimeUnit.MILLISECONDS);
+
+        while (!d.isDisposed()) {
+            Thread.sleep(1);
+        }
+    }
+
+    @Test(timeout = 1000)
+    public void runnableDisposedAsyncTimed2() throws Exception {
+        ExecutorService executorScheduler = Executors.newScheduledThreadPool(1, new RxThreadFactory("TestCustomPoolTimed"));
+        try {
+            final Scheduler s = Schedulers.from(executorScheduler, true);
+            Disposable d = s.scheduleDirect(Functions.EMPTY_RUNNABLE, 1, TimeUnit.MILLISECONDS);
+
+            while (!d.isDisposed()) {
+                Thread.sleep(1);
+            }
+        } finally {
+            executorScheduler.shutdownNow();
+        }
+    }
+
+    @Test
+    public void unwrapScheduleDirectTaskAfterDispose() {
+        Scheduler scheduler = getScheduler();
+        final CountDownLatch cdl = new CountDownLatch(1);
+        Runnable countDownRunnable = new Runnable() {
+            @Override
+            public void run() {
+                cdl.countDown();
+            }
+        };
+        Disposable disposable = scheduler.scheduleDirect(countDownRunnable, 100, TimeUnit.MILLISECONDS);
+        SchedulerRunnableIntrospection wrapper = (SchedulerRunnableIntrospection) disposable;
+        assertSame(countDownRunnable, wrapper.getWrappedRunnable());
+        disposable.dispose();
+
+        assertSame(Functions.EMPTY_RUNNABLE, wrapper.getWrappedRunnable());
+    }
+
+    @Test(timeout = 10000)
+    public void interruptibleDirectTask() throws Exception {
+        Scheduler scheduler = getScheduler();
+
+        final AtomicInteger sync = new AtomicInteger(2);
+
+        final AtomicBoolean isInterrupted = new AtomicBoolean();
+
+        Disposable d = scheduler.scheduleDirect(new Runnable() {
+            @Override
+            public void run() {
+                if (sync.decrementAndGet() != 0) {
+                    while (sync.get() != 0) { }
+                }
+                try {
+                    Thread.sleep(1000);
+                } catch (InterruptedException ex) {
+                    isInterrupted.set(true);
+                }
+            }
+        });
+
+        if (sync.decrementAndGet() != 0) {
+            while (sync.get() != 0) { }
+        }
+
+        Thread.sleep(500);
+
+        d.dispose();
+
+        int i = 20;
+        while (i-- > 0 && !isInterrupted.get()) {
+            Thread.sleep(50);
+        }
+
+        assertTrue("Interruption did not propagate", isInterrupted.get());
+    }
+
+    @Test(timeout = 10000)
+    public void interruptibleWorkerTask() throws Exception {
+        Scheduler scheduler = getScheduler();
+
+        Worker worker = scheduler.createWorker();
+
+        try {
+            final AtomicInteger sync = new AtomicInteger(2);
+
+            final AtomicBoolean isInterrupted = new AtomicBoolean();
+
+            Disposable d = worker.schedule(new Runnable() {
+                @Override
+                public void run() {
+                    if (sync.decrementAndGet() != 0) {
+                        while (sync.get() != 0) { }
+                    }
+                    try {
+                        Thread.sleep(1000);
+                    } catch (InterruptedException ex) {
+                        isInterrupted.set(true);
+                    }
+                }
+            });
+
+            if (sync.decrementAndGet() != 0) {
+                while (sync.get() != 0) { }
+            }
+
+            Thread.sleep(500);
+
+            d.dispose();
+
+            int i = 20;
+            while (i-- > 0 && !isInterrupted.get()) {
+                Thread.sleep(50);
+            }
+
+            assertTrue("Interruption did not propagate", isInterrupted.get());
+        } finally {
+            worker.dispose();
+        }
+    }
+}
diff --git a/src/test/java/io/reactivex/schedulers/TimedTest.java b/src/test/java/io/reactivex/schedulers/TimedTest.java
index 7e8cb41e1a..c380188665 100644
--- a/src/test/java/io/reactivex/schedulers/TimedTest.java
+++ b/src/test/java/io/reactivex/schedulers/TimedTest.java
@@ -75,7 +75,7 @@ public void equalsWith() {
 
         assertNotEquals(new Object(), t1);
 
-        assertFalse(t1.equals(new Object()));
+        assertNotEquals(t1, new Object());
     }
 
     @Test
diff --git a/src/test/java/io/reactivex/schedulers/TrampolineSchedulerTest.java b/src/test/java/io/reactivex/schedulers/TrampolineSchedulerTest.java
index 2768a12b1a..9f651bb50e 100644
--- a/src/test/java/io/reactivex/schedulers/TrampolineSchedulerTest.java
+++ b/src/test/java/io/reactivex/schedulers/TrampolineSchedulerTest.java
@@ -31,7 +31,6 @@
 import org.reactivestreams.Subscriber;
 
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
 
 public class TrampolineSchedulerTest extends AbstractSchedulerTests {
 
@@ -51,7 +50,7 @@ public final void testMergeWithCurrentThreadScheduler1() {
 
             @Override
             public String apply(Integer t) {
-                assertTrue(Thread.currentThread().getName().equals(currentThreadName));
+                assertEquals(Thread.currentThread().getName(), currentThreadName);
                 return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
             }
         });
diff --git a/src/test/java/io/reactivex/single/SingleNullTests.java b/src/test/java/io/reactivex/single/SingleNullTests.java
index ff7ddf19d0..059f106ffe 100644
--- a/src/test/java/io/reactivex/single/SingleNullTests.java
+++ b/src/test/java/io/reactivex/single/SingleNullTests.java
@@ -22,7 +22,6 @@
 import org.reactivestreams.*;
 
 import io.reactivex.*;
-import io.reactivex.SingleOperator;
 import io.reactivex.exceptions.*;
 import io.reactivex.functions.*;
 import io.reactivex.internal.functions.Functions;
diff --git a/src/test/java/io/reactivex/subjects/AsyncSubjectTest.java b/src/test/java/io/reactivex/subjects/AsyncSubjectTest.java
index efd643e8d9..c1be4ab34c 100644
--- a/src/test/java/io/reactivex/subjects/AsyncSubjectTest.java
+++ b/src/test/java/io/reactivex/subjects/AsyncSubjectTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.subjects;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.concurrent.TimeUnit;
diff --git a/src/test/java/io/reactivex/subjects/BehaviorSubjectTest.java b/src/test/java/io/reactivex/subjects/BehaviorSubjectTest.java
index 9a2b52f8f7..1a6f48a0e7 100644
--- a/src/test/java/io/reactivex/subjects/BehaviorSubjectTest.java
+++ b/src/test/java/io/reactivex/subjects/BehaviorSubjectTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.subjects;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/src/test/java/io/reactivex/subjects/PublishSubjectTest.java b/src/test/java/io/reactivex/subjects/PublishSubjectTest.java
index 7731d508f8..fc20c7b195 100644
--- a/src/test/java/io/reactivex/subjects/PublishSubjectTest.java
+++ b/src/test/java/io/reactivex/subjects/PublishSubjectTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.subjects;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.ArrayList;
diff --git a/src/test/java/io/reactivex/subjects/ReplaySubjectTest.java b/src/test/java/io/reactivex/subjects/ReplaySubjectTest.java
index 2326241cfd..ce098ca16d 100644
--- a/src/test/java/io/reactivex/subjects/ReplaySubjectTest.java
+++ b/src/test/java/io/reactivex/subjects/ReplaySubjectTest.java
@@ -14,20 +14,20 @@
 package io.reactivex.subjects;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
+import java.lang.management.*;
 import java.util.Arrays;
 import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.atomic.*;
 
-import org.junit.Test;
+import org.junit.*;
 import org.mockito.*;
 
 import io.reactivex.*;
 import io.reactivex.disposables.*;
 import io.reactivex.exceptions.TestException;
-import io.reactivex.functions.Function;
+import io.reactivex.functions.*;
 import io.reactivex.observers.*;
 import io.reactivex.schedulers.*;
 import io.reactivex.subjects.ReplaySubject.*;
@@ -964,7 +964,7 @@ public void peekStateTimeAndSizeValueExpired() {
 
         scheduler.advanceTimeBy(2, TimeUnit.DAYS);
 
-        assertEquals(null, rp.getValue());
+        assertNull(rp.getValue());
         assertEquals(0, rp.getValues().length);
         assertNull(rp.getValues(new Integer[2])[0]);
     }
@@ -1284,4 +1284,137 @@ public void noHeadRetentionTime() {
 
         assertSame(o, buf.head);
     }
+
+    @Test
+    public void noBoundedRetentionViaThreadLocal() throws Exception {
+        final ReplaySubject rs = ReplaySubject.createWithSize(1);
+
+        Observable source = rs.take(1)
+        .concatMap(new Function>() {
+            @Override
+            public Observable apply(byte[] v) throws Exception {
+                return rs;
+            }
+        })
+        .takeLast(1)
+        ;
+
+        System.out.println("Bounded Replay Leak check: Wait before GC");
+        Thread.sleep(1000);
+
+        System.out.println("Bounded Replay Leak check: GC");
+        System.gc();
+
+        Thread.sleep(500);
+
+        final MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
+        MemoryUsage memHeap = memoryMXBean.getHeapMemoryUsage();
+        long initial = memHeap.getUsed();
+
+        System.out.printf("Bounded Replay Leak check: Starting: %.3f MB%n", initial / 1024.0 / 1024.0);
+
+        final AtomicLong after = new AtomicLong();
+
+        source.subscribe(new Consumer() {
+            @Override
+            public void accept(byte[] v) throws Exception {
+                System.out.println("Bounded Replay Leak check: Wait before GC 2");
+                Thread.sleep(1000);
+
+                System.out.println("Bounded Replay Leak check:  GC 2");
+                System.gc();
+
+                Thread.sleep(500);
+
+                after.set(memoryMXBean.getHeapMemoryUsage().getUsed());
+            }
+        });
+
+        for (int i = 0; i < 200; i++) {
+            rs.onNext(new byte[1024 * 1024]);
+        }
+        rs.onComplete();
+
+        System.out.printf("Bounded Replay Leak check: After: %.3f MB%n", after.get() / 1024.0 / 1024.0);
+
+        if (initial + 100 * 1024 * 1024 < after.get()) {
+            Assert.fail("Bounded Replay Leak check: Memory leak detected: " + (initial / 1024.0 / 1024.0)
+                    + " -> " + after.get() / 1024.0 / 1024.0);
+        }
+    }
+
+    @Test
+    public void timeAndSizeNoTerminalTruncationOnTimechange() {
+        ReplaySubject rs = ReplaySubject.createWithTimeAndSize(1, TimeUnit.SECONDS, new TimesteppingScheduler(), 1);
+
+        TestObserver to = rs.test();
+
+        rs.onNext(1);
+        rs.cleanupBuffer();
+        rs.onComplete();
+
+        to.assertNoErrors()
+        .assertComplete();
+    }
+
+    @Test
+    public void timeAndSizeNoTerminalTruncationOnTimechange2() {
+        ReplaySubject rs = ReplaySubject.createWithTimeAndSize(1, TimeUnit.SECONDS, new TimesteppingScheduler(), 1);
+
+        TestObserver to = rs.test();
+
+        rs.onNext(1);
+        rs.cleanupBuffer();
+        rs.onNext(2);
+        rs.cleanupBuffer();
+        rs.onComplete();
+
+        to.assertNoErrors()
+        .assertComplete();
+    }
+
+    @Test
+    public void timeAndSizeNoTerminalTruncationOnTimechange3() {
+        ReplaySubject rs = ReplaySubject.createWithTimeAndSize(1, TimeUnit.SECONDS, new TimesteppingScheduler(), 1);
+
+        TestObserver to = rs.test();
+
+        rs.onNext(1);
+        rs.onNext(2);
+        rs.onComplete();
+
+        to.assertNoErrors()
+        .assertComplete();
+    }
+
+    @Test
+    public void timeAndSizeNoTerminalTruncationOnTimechange4() {
+        ReplaySubject rs = ReplaySubject.createWithTimeAndSize(1, TimeUnit.SECONDS, new TimesteppingScheduler(), 10);
+
+        TestObserver to = rs.test();
+
+        rs.onNext(1);
+        rs.onNext(2);
+        rs.onComplete();
+
+        to.assertNoErrors()
+        .assertComplete();
+    }
+
+    @Test
+    public void timeAndSizeRemoveCorrectNumberOfOld() {
+        TestScheduler scheduler = new TestScheduler();
+        ReplaySubject rs = ReplaySubject.createWithTimeAndSize(1, TimeUnit.SECONDS, scheduler, 2);
+
+        rs.onNext(1);
+        rs.onNext(2);
+        rs.onNext(3); // remove 1 due to maxSize, size == 2
+
+        scheduler.advanceTimeBy(2, TimeUnit.SECONDS);
+
+        rs.onNext(4); // remove 2 due to maxSize, remove 3 due to age, size == 1
+        rs.onNext(5); // size == 2
+
+        rs.test().assertValuesOnly(4, 5);
+    }
 }
diff --git a/src/test/java/io/reactivex/subjects/UnicastSubjectTest.java b/src/test/java/io/reactivex/subjects/UnicastSubjectTest.java
index ca13ba0495..ea68601722 100644
--- a/src/test/java/io/reactivex/subjects/UnicastSubjectTest.java
+++ b/src/test/java/io/reactivex/subjects/UnicastSubjectTest.java
@@ -17,16 +17,19 @@
 import static org.mockito.Mockito.mock;
 
 import java.util.List;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.Test;
 
 import io.reactivex.*;
 import io.reactivex.disposables.*;
-import io.reactivex.exceptions.TestException;
-import io.reactivex.internal.fuseable.*;
+import io.reactivex.exceptions.*;
+import io.reactivex.internal.functions.Functions;
+import io.reactivex.internal.fuseable.QueueFuseable;
 import io.reactivex.observers.*;
 import io.reactivex.plugins.RxJavaPlugins;
+import io.reactivex.schedulers.Schedulers;
 
 public class UnicastSubjectTest extends SubjectTest {
 
@@ -168,9 +171,9 @@ public void onTerminateCalledWhenOnError() {
             }
         });
 
-        assertEquals(false, didRunOnTerminate.get());
+        assertFalse(didRunOnTerminate.get());
         us.onError(new RuntimeException("some error"));
-        assertEquals(true, didRunOnTerminate.get());
+        assertTrue(didRunOnTerminate.get());
     }
 
     @Test
@@ -183,9 +186,9 @@ public void onTerminateCalledWhenOnComplete() {
             }
         });
 
-        assertEquals(false, didRunOnTerminate.get());
+        assertFalse(didRunOnTerminate.get());
         us.onComplete();
-        assertEquals(true, didRunOnTerminate.get());
+        assertTrue(didRunOnTerminate.get());
     }
 
     @Test
@@ -200,9 +203,9 @@ public void onTerminateCalledWhenCanceled() {
 
         final Disposable subscribe = us.subscribe();
 
-        assertEquals(false, didRunOnTerminate.get());
+        assertFalse(didRunOnTerminate.get());
         subscribe.dispose();
-        assertEquals(true, didRunOnTerminate.get());
+        assertTrue(didRunOnTerminate.get());
     }
 
     @Test(expected = NullPointerException.class)
@@ -456,4 +459,37 @@ public void drainFusedFailFastEmpty() {
 
         to.assertEmpty();
     }
+
+    @Test
+    public void fusedNoConcurrentCleanDueToCancel() {
+        for (int j = 0; j < TestHelper.RACE_LONG_LOOPS; j++) {
+            List errors = TestHelper.trackPluginErrors();
+            try {
+                final UnicastSubject us = UnicastSubject.create();
+
+                TestObserver to = us
+                .observeOn(Schedulers.io())
+                .map(Functions.identity())
+                .observeOn(Schedulers.single())
+                .firstOrError()
+                .test();
+
+                for (int i = 0; us.hasObservers(); i++) {
+                    us.onNext(i);
+                }
+
+                to
+                .awaitDone(5, TimeUnit.SECONDS)
+                ;
+
+                if (!errors.isEmpty()) {
+                    throw new CompositeException(errors);
+                }
+
+                to.assertResult(0);
+            } finally {
+                RxJavaPlugins.reset();
+            }
+        }
+    }
 }
diff --git a/src/test/java/io/reactivex/subscribers/SerializedSubscriberTest.java b/src/test/java/io/reactivex/subscribers/SerializedSubscriberTest.java
index c38105eb68..e0524350c9 100644
--- a/src/test/java/io/reactivex/subscribers/SerializedSubscriberTest.java
+++ b/src/test/java/io/reactivex/subscribers/SerializedSubscriberTest.java
@@ -14,7 +14,6 @@
 package io.reactivex.subscribers;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 import java.util.List;